duoops 0.1.9 → 0.2.1

package/data/runtime-pue-mappings.json

@@ -0,0 +1,183 @@
+{
+  "metadata": {
+    "generatedAt": "2025-06-14T16:09:07.455Z",
+    "methodology": "Real-time Electricity Maps API with industry standard PUE",
+    "availableZones": [
+      "US-CENT-SWPP"
+    ]
+  },
+  "regions": {
+    "us-central1": {
+      "zone": "US-CENT-SWPP",
+      "industryStandardPUE": 1.1,
+      "realTimeCarbonIntensity": 492,
+      "googleOfficialIntensity": 430,
+      "cfe": 0.95
+    },
+    "us-east1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "us-east4": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "us-west1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "us-west2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "us-west3": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "us-west4": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "us-south1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west3": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west4": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west6": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west8": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west9": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west10": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-west12": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-north1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-central2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "europe-southwest1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-east1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-east2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-northeast1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-northeast2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-northeast3": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-south1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-south2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-southeast1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "asia-southeast2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "australia-southeast1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "australia-southeast2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "southamerica-east1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "northamerica-northeast1": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    },
+    "northamerica-northeast2": {
+      "zone": "FALLBACK",
+      "industryStandardPUE": 1.1,
+      "error": "No matching zone found in available zones"
+    }
+  }
+}

package/dist/commands/autofix-ci.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class AutofixCi extends Command {
+    static args: {
+        'project-id': import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        mr: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/autofix-ci.js

@@ -0,0 +1,114 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { runAgent } from '../lib/ai/agent.js';
+import { configManager } from '../lib/config.js';
+import { createGitlabClient } from '../lib/gitlab/client.js';
+import { getPipelineProvider } from '../lib/gitlab/index.js';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export default class AutofixCi extends Command {
+    static args = {
+        'project-id': Args.string({
+            description: 'GitLab project ID or path (falls back to DUOOPS_PROJECT_ID, CI_PROJECT_ID, or duoops init default)',
+            required: false,
+        }),
+    };
+    static description = 'Headless autofix: analyze the latest failing pipeline and post results to an MR or stdout';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> 12345 --mr 42',
+        '<%= config.bin %> <%= command.id %> my-group/my-project --pipeline 99999',
+    ];
+    static flags = {
+        mr: Flags.integer({
+            description: 'Merge request IID to comment the analysis on',
+        }),
+        pipeline: Flags.integer({
+            description: 'Pipeline ID to analyze (defaults to latest failed)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(AutofixCi);
+        const config = configManager.get();
+        const projectId = args['project-id'] ??
+            process.env.DUOOPS_PROJECT_ID ??
+            process.env.CI_PROJECT_ID ??
+            config.defaultProjectId;
+        if (!projectId) {
+            this.error('Project ID is required. Pass it as an argument, set DUOOPS_PROJECT_ID / CI_PROJECT_ID, or run "duoops init".');
+        }
+        const provider = getPipelineProvider();
+        let pipeline = null;
+        if (flags.pipeline) {
+            pipeline = await provider.getPipeline(projectId, flags.pipeline);
+        }
+        else {
+            this.log('Looking for the latest failing pipeline...');
+            const pipelines = await provider.listPipelines(projectId, { perPage: 10, status: 'failed' });
+            pipeline = pipelines.find((p) => p.status === 'failed') ?? null;
+        }
+        if (!pipeline) {
+            this.log('No failing pipelines found. Nothing to fix.');
+            return;
+        }
+        this.log(`Analyzing pipeline ${pipeline.id} (${pipeline.status}) on ref ${pipeline.ref}...`);
+        const jobs = await provider.listJobs(projectId, pipeline.id);
+        const prompt = buildAutofixPrompt(pipeline, jobs);
+        this.log('Running agent analysis...');
+        const analysis = await runAgent(prompt, { projectId });
+        if (flags.mr) {
+            this.log(`Posting analysis to MR !${flags.mr}...`);
+            await postMrNote(projectId, flags.mr, analysis, pipeline);
+            this.log('Done. Analysis posted to the merge request.');
+        }
+        else if (process.env.CI_MERGE_REQUEST_IID) {
+            const mrIid = Number(process.env.CI_MERGE_REQUEST_IID);
+            this.log(`Posting analysis to MR !${mrIid} (from CI_MERGE_REQUEST_IID)...`);
+            await postMrNote(projectId, mrIid, analysis, pipeline);
+            this.log('Done. Analysis posted to the merge request.');
+        }
+        else {
+            this.log('\n' + analysis);
+        }
+    }
+}
+async function postMrNote(projectId, mrIid, analysis, pipeline) {
+    const client = createGitlabClient();
+    const body = `## DuoOps Autofix Analysis
+
+**Pipeline:** [#${pipeline.id}](${pipeline.webUrl ?? ''}) | **Ref:** \`${pipeline.ref}\` | **Status:** ${pipeline.status}
+
+---
+
+${analysis}
+
+---
+*Generated by [DuoOps](https://gitlab.com/youneslaaroussi/duoops) autofix agent*`;
+    await client.MergeRequestNotes.create(projectId, mrIid, body);
+}
+function buildAutofixPrompt(pipeline, jobs) {
+    const jobSummary = jobs.length === 0
+        ? 'No jobs were returned for this pipeline.'
+        : jobs
+            .map((job) => `• Job ${job.id} (${job.name}) in stage ${job.stage} - status: ${job.status}${job.duration ? `, duration: ${job.duration}s` : ''}`)
+            .join('\n');
+    return `You are DuoOps, an AI pair engineer focused on CI/CD reliability and sustainability.
+Inspect the following failing pipeline and propose actionable fixes.
+
+Pipeline:
+- ID: ${pipeline.id}
+- Ref: ${pipeline.ref}
+- Status: ${pipeline.status}
+- SHA: ${pipeline.sha}
+- URL: ${pipeline.webUrl ?? 'n/a'}
+
+Jobs:
+${jobSummary}
+
+Instructions:
+1. Use the get_job_logs tool to fetch logs for ALL failed jobs. This is critical.
+2. Identify the root cause of the failure based on the logs and job statuses.
+3. Propose concrete remediation steps, referencing jobs and stages explicitly.
+4. Suggest any GitLab CI configuration changes or code adjustments to prevent this regression.
+5. Outline validation steps once the fix is applied.
+
+Respond in Markdown with clear sections: Root Cause, Fix Plan, Validation.`;
+}

package/dist/commands/autofix.d.ts

@@ -0,0 +1,5 @@
+import Portal from './portal.js';
+export default class Autofix extends Portal {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/autofix.js

@@ -0,0 +1,11 @@
+import Portal from './portal.js';
+const AUTO_MESSAGE = 'Please inspect the most recent failing pipeline, diagnose the issue, and propose a fix.';
+export default class Autofix extends Portal {
+    static description = 'Launch the DuoOps portal and pre-fill an autofix request to the agent';
+    async run() {
+        process.env.DUOOPS_PORTAL_DEFAULT_TAB = 'console';
+        process.env.DUOOPS_PORTAL_PRESET_MESSAGE = AUTO_MESSAGE;
+        this.log('Launching DuoOps portal with an autofix prompt...');
+        await super.run();
+    }
+}

package/dist/commands/init.js

@@ -9,6 +9,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { configManager } from '../lib/config.js';
+import { detectGcpProject, enableApis, validateProjectAccess } from '../lib/gcloud.js';
+import McpDeploy from './mcp/deploy.js';
 const hasBinary = (command) => {
     try {
         execSync(`${command} --version`, { stdio: 'ignore' });
@@ -18,6 +20,29 @@ const hasBinary = (command) => {
         return false;
     }
 };
+const detectGlabToken = (host = 'gitlab.com') => {
+    const candidates = [
+        path.join(os.homedir(), '.config', 'glab-cli', 'config.yml'),
+        path.join(os.homedir(), 'Library', 'Application Support', 'glab-cli', 'config.yml'),
+    ];
+    for (const configPath of candidates) {
+        try {
+            if (!fs.existsSync(configPath))
+                continue;
+            const content = fs.readFileSync(configPath, 'utf8');
+            const hostSection = content.split(`${host}:`)[1];
+            if (!hostSection)
+                continue;
+            const isOauth = hostSection.match(/is_oauth2:\s*"?true"?/);
+            if (isOauth)
+                continue;
+            const tokenMatch = hostSection.match(/token:\s*(?:!!null\s+)?(\S+)/);
+            if (tokenMatch?.[1] && tokenMatch[1].startsWith('glpat-'))
+                return tokenMatch[1];
+        }
+        catch { /* ignore */ }
+    }
+};
 const detectGitRemotePath = () => {
     try {
         const remote = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
@@ -32,13 +57,6 @@ const detectGitRemotePath = () => {
     }
     catch { /* ignore */ }
 };
-const detectGcpProject = () => {
-    try {
-        const value = execSync('gcloud config get-value project', { encoding: 'utf8' }).trim();
-        return value && value !== '(unset)' ? value : undefined;
-    }
-    catch { }
-};
 const normalizeProjectPath = (project) => project.replace(/^\/+/, '');
 const normalizeGitLabUrl = (url) => url.replace(/\/+$/, '');
 const setGitlabVariable = async (auth, projectPath, variable) => {
@@ -79,23 +97,6 @@ const createServiceAccountKey = (projectId, serviceAccount) => {
     fs.unlinkSync(tmpPath);
     return contents.toString('base64');
 };
-const ensureServiceEnabled = (projectId, service, label, log) => {
-    try {
-        log?.(gray(`Ensuring ${label} API is enabled...`));
-        execSync(`gcloud services enable ${service} --project=${projectId} --quiet`, {
-            stdio: 'ignore',
-        });
-    }
-    catch {
-        log?.(gray(`${label} API enablement skipped (it may already be enabled).`));
-    }
-};
-const ensureComputeApiEnabled = (projectId, log) => {
-    ensureServiceEnabled(projectId, 'compute.googleapis.com', 'Compute Engine', log);
-};
-const ensureMonitoringApiEnabled = (projectId, log) => {
-    ensureServiceEnabled(projectId, 'monitoring.googleapis.com', 'Cloud Monitoring', log);
-};
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -270,16 +271,41 @@ export default class Init extends Command {
     static description = 'Initialize DuoOps, optionally wiring a GitLab project and GCP runner';
     async run() {
         this.log(bold('Welcome to DuoOps!'));
-        this.log('You will need a GitLab Personal Access Token with the "api" scope.');
-        this.log('Create one at https://gitlab.com/-/user_settings/personal_access_tokens\n');
         const gitlabUrl = await input({
             default: 'https://gitlab.com',
             message: 'GitLab URL',
         });
-        const gitlabToken = await password({
-            mask: '*',
-            message: 'GitLab Personal Access Token',
-        });
+        const { host } = new URL(gitlabUrl);
+        const glabToken = detectGlabToken(host);
+        const envToken = process.env.GITLAB_TOKEN || process.env.GL_TOKEN;
+        let gitlabToken;
+        if (glabToken || envToken) {
+            const source = glabToken ? 'glab CLI' : 'environment';
+            const detected = glabToken || envToken;
+            const masked = detected.slice(0, 6) + '...' + detected.slice(-4);
+            const useDetected = await confirm({
+                default: true,
+                message: `Found GitLab token from ${source} (${masked}). Use it?`,
+            });
+            if (useDetected) {
+                gitlabToken = detected;
+            }
+            else {
+                this.log('Create one at https://gitlab.com/-/user_settings/personal_access_tokens\n');
+                gitlabToken = await password({
+                    mask: '*',
+                    message: 'GitLab Personal Access Token',
+                });
+            }
+        }
+        else {
+            this.log('You will need a GitLab Personal Access Token with the "api" scope.');
+            this.log('Create one at https://gitlab.com/-/user_settings/personal_access_tokens\n');
+            gitlabToken = await password({
+                mask: '*',
+                message: 'GitLab Personal Access Token',
+            });
+        }
         const enableMeasure = await confirm({
             message: 'Enable Measure/Sustainability Tracking (BigQuery)?',
         });
@@ -354,7 +380,40 @@ export default class Init extends Command {
         };
         configManager.set(config);
         this.log(green('Configuration saved.'));
-        this.log(`Try '${this.config.bin} pipelines:list <project>' to verify GitLab access.\n`);
+        const setupAgents = await confirm({
+            default: true,
+            message: 'Set up DuoOps agents and flows in this project?',
+        });
+        if (setupAgents) {
+            const { scaffoldProject } = await import('../lib/scaffold.js');
+            const result = scaffoldProject(process.cwd());
+            for (const f of result.created) {
+                this.log(green(`  ✓ Created ${f}`));
+            }
+            for (const f of result.skipped) {
+                this.log(gray(`  · Skipped ${f} (already exists)`));
+            }
+        }
+        this.log(`\nTry '${this.config.bin} pipelines:list <project>' to verify GitLab access.\n`);
+        if (enableMeasure) {
+            const deployMcp = await confirm({
+                default: true,
+                message: 'Deploy the DuoOps MCP Server to Cloud Run now?',
+            });
+            if (deployMcp && googleProjectId && bigqueryDataset && bigqueryTable) {
+                try {
+                    await McpDeploy.run([
+                        '--gcp-project', googleProjectId,
+                        '--bq-dataset', bigqueryDataset,
+                        '--bq-table', bigqueryTable,
+                        '--gitlab-url', gitlabUrl,
+                    ]);
+                }
+                catch (error) {
+                    this.warn(`MCP Deployment failed: ${error}`);
+                }
+            }
+        }
         const configureProject = await confirm({
             default: true,
             message: 'Configure a GitLab project (CI variables + optional GCP runner) now?',
@@ -418,6 +477,14 @@ export default class Init extends Command {
             this.warn('GCP Project ID is required to collect metrics.');
             return setAsDefault ? projectPath : undefined;
         }
+        try {
+            validateProjectAccess(gcpProjectId);
+            this.log(green(`  ✓ Verified access to ${gcpProjectId}`));
+        }
+        catch (error) {
+            this.warn(error.message);
+            return setAsDefault ? projectPath : undefined;
+        }
         let serviceAccountEmail = await input({
             default: `duoops-runner@${gcpProjectId}.iam.gserviceaccount.com`,
             message: 'Service account email for DuoOps measurements',
@@ -522,8 +589,12 @@ export default class Init extends Command {
             default: 'gcp',
             message: 'Runner tag (GitLab jobs will use this)',
         });
-        ensureComputeApiEnabled(gcpProjectId, (message) => this.log(message));
-        ensureMonitoringApiEnabled(gcpProjectId, (message) => this.log(message));
+        try {
+            enableApis(gcpProjectId, ['compute.googleapis.com', 'monitoring.googleapis.com'], (msg) => this.log(gray(msg)));
+        }
+        catch (error) {
+            this.warn(error.message);
+        }
         let runnerToken = tryCreateRunnerToken(projectPath, vmName, runnerTag);
         if (!runnerToken) {
             this.log(gray('Unable to create a runner token automatically. Generate one in your GitLab project (Settings → CI/CD → Runners) and paste it below.'));

package/dist/commands/mcp/deploy.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class McpDeploy extends Command {
+    static description: string;
+    static flags: {
+        'bq-dataset': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'bq-table': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'gcp-project': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'gitlab-url': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        region: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        source: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/mcp/deploy.js

@@ -0,0 +1,139 @@
+import { confirm, input } from '@inquirer/prompts';
+import { Command, Flags } from '@oclif/core';
+import { bold, cyan, gray, green } from 'kleur/colors';
+import { execSync } from 'node:child_process';
+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';
+export default class McpDeploy extends Command {
+    static description = 'Deploy the DuoOps MCP server to Google Cloud Run';
+    static flags = {
+        'bq-dataset': Flags.string({ description: 'BigQuery Dataset ID' }),
+        'bq-table': Flags.string({ description: 'BigQuery Table ID' }),
+        'gcp-project': Flags.string({ char: 'p', description: 'Google Cloud Project ID' }),
+        'gitlab-url': Flags.string({ default: 'https://gitlab.com', description: 'GitLab instance URL' }),
+        region: Flags.string({ char: 'r', default: 'us-central1', description: 'Cloud Run region' }),
+        'source': Flags.string({ default: '', description: 'Path to MCP server source directory' }),
+    };
+    async run() {
+        const { flags } = await this.parse(McpDeploy);
+        const config = configManager.get();
+        const gcpProject = flags['gcp-project'] || config.measure?.googleProjectId || await input({
+            default: detectGcpProject(),
+            message: 'Google Cloud Project ID',
+        });
+        const bqDataset = flags['bq-dataset'] || config.measure?.bigqueryDataset || await input({
+            default: 'measure_data',
+            message: 'BigQuery Dataset',
+        });
+        const bqTable = flags['bq-table'] || config.measure?.bigqueryTable || await input({
+            default: 'emissions',
+            message: 'BigQuery Table',
+        });
+        const region = flags.region || await input({
+            default: 'us-central1',
+            message: 'Cloud Run region',
+        });
+        const gitlabUrl = flags['gitlab-url'] || config.gitlabUrl || await input({
+            default: 'https://gitlab.com',
+            message: 'GitLab instance URL',
+        });
+        if (!gcpProject) {
+            this.error('Google Cloud Project ID is required.');
+        }
+        this.log(bold('Deploying DuoOps MCP Server...'));
+        this.log(gray(`Project: ${gcpProject}`));
+        this.log(gray(`Region:  ${region}`));
+        this.log(gray(`Dataset: ${bqDataset}.${bqTable}`));
+        try {
+            requireGcloud();
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        const account = getActiveAccount();
+        this.log(gray(`Account: ${account}`));
+        try {
+            validateProjectAccess(gcpProject);
+            this.log(green(`  ✓ Verified access to ${gcpProject}`));
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        this.log(gray('\nEnabling required GCP APIs...'));
+        try {
+            enableApis(gcpProject, [
+                'run.googleapis.com',
+                'artifactregistry.googleapis.com',
+                'cloudbuild.googleapis.com',
+            ], (msg) => this.log(gray(msg)));
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        this.log(gray('\nConfiguring Cloud Build service account...'));
+        ensureCloudBuildServiceAccount(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.`);
+        }
+        const serviceName = 'duoops-mcp';
+        const cmd = `gcloud run deploy ${serviceName} \
+      --source ${mcpServerDir} \
+      --project ${gcpProject} \
+      --region ${region} \
+      --platform managed \
+      --allow-unauthenticated \
+      --set-env-vars "GCP_PROJECT_ID=${gcpProject},BQ_DATASET=${bqDataset},BQ_TABLE=${bqTable},GITLAB_URL=${gitlabUrl}" \
+      --format="value(status.url)"`;
+        this.log(gray(`\nBuilding and deploying from ${mcpServerDir}...`));
+        this.log(gray('(This uses Cloud Build and may take 2-3 minutes)\n'));
+        let serviceUrl = '';
+        try {
+            serviceUrl = execSync(cmd, { encoding: 'utf8', stdio: ['inherit', 'pipe', 'inherit'] }).trim();
+        }
+        catch (error) {
+            const err = error;
+            this.error(`Deployment failed: ${err.stdout || ''}\n${err.stderr || error.message}`);
+        }
+        if (!serviceUrl) {
+            this.error('Deployment succeeded but failed to retrieve service URL.');
+        }
+        this.log(green(`\n✔ Successfully deployed to: ${bold(serviceUrl)}`));
+        this.log(gray('Running health check...'));
+        try {
+            const health = execSync(`curl -sf ${serviceUrl}/health`, { encoding: 'utf8', timeout: 10_000 }).trim();
+            this.log(green(`  ✓ ${health}`));
+        }
+        catch {
+            this.warn('Health check failed — server may still be starting up. Try: curl ' + serviceUrl + '/health');
+        }
+        const mcpConfig = {
+            mcpServers: {
+                "duoops-carbon": {
+                    approvedTools: true,
+                    type: "http",
+                    url: `${serviceUrl}/mcp`
+                }
+            }
+        };
+        const configStr = JSON.stringify(mcpConfig, null, 2);
+        this.log(bold('\nMCP Configuration:'));
+        this.log(cyan(configStr));
+        const writeConfig = await confirm({
+            default: true,
+            message: 'Write mcp.json to .gitlab/duo/mcp.json?',
+        });
+        if (writeConfig) {
+            const configDir = path.join(process.cwd(), '.gitlab', 'duo');
+            const configPath = path.join(configDir, 'mcp.json');
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            fs.writeFileSync(configPath, configStr);
+            this.log(green(`Wrote configuration to ${configPath}`));
+        }
+    }
+}