gitgreen 1.0.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 GitGreen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,51 @@
 # GitGreen CLI
 
-Self-contained carbon calculation CLI for GitLab jobs (no API server). It reuses the same power profiles and budget reporting as the existing implementation, pulls Electricity Maps intensity, and can post Merge Request notes via `CI_JOB_TOKEN`.
+Self-contained carbon calculation CLI for GitLab jobs (no API server). It reuses the same power profiles and budget reporting as the existing implementation, pulls Electricity Maps intensity, and can post Merge Request notes via `CI_JOB_TOKEN`. Works with both GCP and AWS runners.
+
+## Prerequisites
+
+Before installing GitGreen CLI, ensure you have the following installed and configured:
+
+### Required
+
+- **Node.js** (v20 or higher) - [Download](https://nodejs.org/)
+  - Required to run the CLI tool
+  - Check version: `node --version`
+
+- **npm** or **pnpm** - Package manager (comes with Node.js)
+  - This project uses `pnpm@8.15.4` as the package manager
+  - Install pnpm: `npm install -g pnpm`
+
+- **Git** - [Download](https://git-scm.com/)
+  - Required for detecting GitLab project information during initialization
+  - Check version: `git --version`
+
+### Cloud Provider CLIs (Required based on provider)
+
+- **Google Cloud SDK (gcloud CLI)** - [Installation Guide](https://cloud.google.com/sdk/docs/install-sdk)
+  - Required for GCP provider setup and authentication
+  - After installation, authenticate: `gcloud auth login`
+  - Set default project: `gcloud config set project YOUR_PROJECT_ID`
+  - Check version: `gcloud --version`
+
+- **AWS Credentials** - [AWS CLI Installation](https://aws.amazon.com/cli/) (optional, but recommended)
+  - Required for AWS provider (can use environment variables or AWS CLI config)
+  - Configure credentials: `aws configure`
+  - Or set environment variables: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`
+
+### Optional (but recommended)
+
+- **GitLab CLI (glab)** - [Installation Guide](https://docs.gitlab.com/cli/)
+  - Recommended for easier GitLab authentication and CI/CD variable management
+  - After installation, authenticate: `glab auth login`
+  - Check version: `glab --version`
+  - If not installed, you'll need to provide a GitLab Personal Access Token manually
+
+### API Keys
+
+- **Electricity Maps API Key** - [Get free key](https://api-portal.electricitymaps.com)
+  - Required for carbon intensity data
+  - You'll be prompted for this during `gitgreen init`
 
 ## Install
 - From npm (global CLI):
@@ -48,11 +93,17 @@ Once initialized, all subsequent pipelines will run on the configured runner, an
 Key environment variables:
 - `ELECTRICITY_MAPS_API_KEY` (required) - Get a free key from https://api-portal.electricitymaps.com
 - `GCP_PROJECT_ID` / `GOOGLE_CLOUD_PROJECT` (required for GCP) - Your GCP project ID
+- `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY` (required for AWS CloudWatch) - Credentials with CloudWatch read access on the runner
+- `AWS_REGION` (for AWS) - Region of the runner EC2 instance
 
 The `gitgreen init` wizard will automatically set all necessary GitLab CI/CD variables for you.
 
 ## Providers
+
+GitGreen supports multiple cloud providers:
+
 - **GCP**: Fully wired — the CLI parser expects GCP Monitoring JSON, the GitLab component polls GCE metrics, and `gitgreen init` provisions or reuses GCP runners.
+- **AWS**: CloudWatch-backed — the CLI can pull metrics directly via `--from-cloudwatch`, the GitLab component fetches CloudWatch CPU/RAM data, and `gitgreen init` can configure or provision EC2 runners.
 
 ## Architecture
 Runtime flow:
@@ -83,8 +134,8 @@ CPU/RAM timeseries (GCP Monitoring JSON or custom collector)
 
 GitLab CI path:
 ```
-Pipeline starts → component script fetches CPU/RAM timeseries from GCP Monitoring
-              → writes JSON files → runs `gitgreen --provider gcp ...`
+Pipeline starts → component script fetches CPU/RAM timeseries from GCP Monitoring or AWS CloudWatch
+              → writes JSON files → runs `gitgreen --provider gcp|aws ...`
               → emits `carbon-report.md` / `carbon-report.json`
               → optional MR note when CI_JOB_TOKEN is present
 ```
@@ -100,3 +151,91 @@ Pipeline starts → component script fetches CPU/RAM timeseries from GCP Monitor
 - Ensure version bump in `package.json`
 - Run `pnpm -C node-module build && pnpm -C node-module test`
 - Publish: `pnpm -C node-module publish --access public`
+
+## FAQ
+
+### Are my API keys and credentials secure?
+
+Yes. GitGreen does not save your keys locally. During `gitgreen init`, all sensitive credentials (API keys, service account keys, AWS credentials) are stored only in GitLab CI/CD variables, which are encrypted and managed by GitLab. The CLI never writes credentials to disk on your local machine.
+
+### Does GitGreen call any third-party APIs?
+
+GitGreen only calls APIs that you explicitly configure and authorize:
+
+- **Electricity Maps API** - For carbon intensity data (requires your API key)
+- **GitLab API** - Only when using `glab` CLI or providing a PAT, to set CI/CD variables
+- **GCP Monitoring API** - To fetch CPU/RAM metrics from your GCP project (requires your service account)
+- **AWS CloudWatch API** - To fetch CPU/RAM metrics from your AWS account (requires your AWS credentials)
+
+GitGreen does not operate any backend services or call any APIs owned by the GitGreen project. All API calls are made directly from your environment or CI/CD pipeline using your credentials.
+
+### How do I know GitGreen won't destroy my `.gitlab-ci.yml` file?
+
+GitGreen takes safety precautions when modifying your `.gitlab-ci.yml`:
+
+1. **Automatic backups** - Before making any changes, GitGreen creates a backup of your existing `.gitlab-ci.yml` file
+2. **Backup location** - The backup path is printed to the console (e.g., `/tmp/gitlab-ci-backup-{timestamp}.yml`)
+3. **Append-only changes** - GitGreen only appends new content to your CI file; it never removes or modifies existing jobs
+4. **Confirmation prompt** - You're asked to confirm before any changes are made
+
+If something goes wrong, you can restore your file from the backup location that was printed.
+
+### Can I use GitGreen without the `init` wizard?
+
+Yes. You can configure GitGreen manually by:
+
+1. Setting the required CI/CD variables in your GitLab project settings
+2. Adding the GitLab CI/CD component to your `.gitlab-ci.yml` manually
+3. Running `gitgreen` directly with command-line options instead of using the component
+
+The `init` wizard is a convenience tool, but all functionality is available through manual configuration.
+
+### What data does GitGreen collect?
+
+GitGreen only collects:
+
+- **CPU and RAM usage metrics** from your cloud provider (GCP Monitoring or AWS CloudWatch)
+- **Pipeline metadata** (start/end times) from GitLab CI/CD environment variables
+
+GitGreen does not collect any personal information, code, or data from your repositories. All calculations happen locally in your CI/CD pipeline.
+
+### Can I run GitGreen locally for testing?
+
+Yes. You can run `gitgreen` directly with your own metrics files:
+
+**GCP example:**
+```bash
+gitgreen --provider gcp \
+  --machine e2-standard-4 \
+  --region us-central1-a \
+  --cpu-timeseries cpu.json \
+  --ram-used-timeseries ram-used.json \
+  --ram-size-timeseries ram-size.json \
+  --out-md report.md
+```
+
+**AWS example:**
+```bash
+gitgreen --provider aws \
+  --machine t3.medium \
+  --region us-east-1 \
+  --cpu-timeseries cpu.json \
+  --ram-used-timeseries ram-used.json \
+  --ram-size-timeseries ram-size.json \
+  --out-md report.md
+```
+
+Or use `--from-cloudwatch` to fetch metrics directly from AWS CloudWatch:
+```bash
+gitgreen --provider aws \
+  --machine t3.medium \
+  --region us-east-1 \
+  --from-cloudwatch \
+  --out-md report.md
+```
+
+This is useful for testing before integrating into your CI/CD pipeline.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.

package/dist/cli.js

@@ -8,47 +8,217 @@ const fs_1 = __importDefault(require("fs"));
 const commander_1 = require("commander");
 const kleur_1 = require("kleur");
 const asciichart_1 = __importDefault(require("asciichart"));
+const config_1 = require("./config");
 const index_1 = require("./index");
 const init_1 = require("./init");
+const cloudwatch_1 = require("./lib/aws/cloudwatch");
+const power_profile_repository_1 = require("./lib/carbon/power-profile-repository");
 const program = new commander_1.Command();
-function parseGcpTimeseries(filePath) {
+const toIsoTimestamp = (input) => {
+    if (input instanceof Date) {
+        return Number.isNaN(input.getTime()) ? undefined : input.toISOString();
+    }
+    if (typeof input === 'string' || typeof input === 'number') {
+        const date = new Date(input);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    return undefined;
+};
+const toNumericValue = (input) => {
+    if (typeof input === 'number') {
+        return Number.isFinite(input) ? input : undefined;
+    }
+    if (typeof input === 'string') {
+        const parsed = Number(input);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+};
+const formatErrorMessage = (value) => {
+    if (value instanceof Error)
+        return value.message;
+    if (value === null || value === undefined)
+        return 'Unknown error';
+    return String(value);
+};
+const parseGcpTimeseries = (raw) => {
+    const points = [];
+    const response = raw;
+    const timeSeries = response.timeSeries;
+    if (!Array.isArray(timeSeries))
+        return points;
+    for (const ts of timeSeries) {
+        const series = ts;
+        if (!Array.isArray(series.points))
+            continue;
+        for (const point of series.points) {
+            const timestamp = toIsoTimestamp(point.interval?.endTime || point.interval?.startTime);
+            const value = point.value?.doubleValue !== undefined
+                ? toNumericValue(point.value.doubleValue)
+                : toNumericValue(point.value?.int64Value);
+            if (timestamp && value !== undefined)
+                points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
+const parseCloudWatchMetricData = (raw) => {
+    const data = raw.MetricDataResults || raw.metricDataResults;
+    const results = Array.isArray(data) ? data : [];
+    if (!results.length)
+        return [];
+    const first = results[0];
+    const timestamps = Array.isArray(first?.Timestamps) ? first.Timestamps : [];
+    const values = Array.isArray(first?.Values) ? first.Values : [];
+    const len = Math.min(timestamps.length, values.length);
+    const points = [];
+    for (let i = 0; i < len; i++) {
+        const timestamp = toIsoTimestamp(timestamps[i]);
+        const value = toNumericValue(values[i]);
+        if (timestamp && value !== undefined) {
+            points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
+const parseTimeseriesFile = (filePath) => {
     const raw = JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+    const gcp = parseGcpTimeseries(raw);
+    if (gcp.length)
+        return gcp;
+    const cw = parseCloudWatchMetricData(raw);
+    if (cw.length)
+        return cw;
+    if (Array.isArray(raw)) {
+        const cwFromArray = parseCloudWatchMetricData({ MetricDataResults: raw });
+        if (cwFromArray.length)
+            return cwFromArray;
+        const legacy = parseLegacyTimeseries(raw);
+        if (legacy.length)
+            return legacy;
+    }
+    const datapointResponse = raw;
+    if (Array.isArray(datapointResponse.Datapoints)) {
+        const datapointSeries = convertCloudWatchDatapoints(datapointResponse.Datapoints);
+        if (datapointSeries.length)
+            return datapointSeries;
+    }
+    return [];
+};
+const parseLegacyTimeseries = (entries) => {
     const points = [];
-    for (const ts of raw.timeSeries || []) {
-        for (const p of ts.points || []) {
-            const timestamp = p.interval?.endTime || p.interval?.startTime;
-            let value;
-            if (p.value?.doubleValue !== undefined) {
-                value = p.value.doubleValue;
-            }
-            else if (p.value?.int64Value !== undefined) {
-                value = Number(p.value.int64Value);
-            }
-            else {
-                continue;
-            }
+    for (const entry of entries) {
+        const timestamp = toIsoTimestamp((entry.timestamp ?? entry.Timestamp));
+        const value = toNumericValue((entry.value ?? entry.Value));
+        if (timestamp && value !== undefined) {
             points.push({ timestamp, value });
         }
     }
     return points;
-}
+};
+const convertCloudWatchDatapoints = (entries) => {
+    const points = [];
+    for (const entry of entries) {
+        const timestamp = toIsoTimestamp(entry.Timestamp);
+        const value = toNumericValue((entry.Average ?? entry.Maximum ?? entry.Minimum ?? entry.Sum));
+        if (timestamp && value !== undefined) {
+            points.push({ timestamp, value });
+        }
+    }
+    return points;
+};
 const runCalculate = async (opts) => {
     const gitlabDisabled = opts.gitlab === false;
-    if (!opts.cpuTimeseries || !opts.ramUsedTimeseries || !opts.ramSizeTimeseries) {
-        console.error((0, kleur_1.red)('Error: --cpu-timeseries, --ram-used-timeseries, and --ram-size-timeseries are required'));
+    const provider = (opts.provider || config_1.config.defaultProvider);
+    const regionInput = opts.region || opts.awsRegion;
+    const awsEnvRegion = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION;
+    const calculationRegion = provider === 'aws' ? (regionInput || awsEnvRegion) : regionInput;
+    if (!opts.machine) {
+        console.error((0, kleur_1.red)('Error: --machine is required'));
+        process.exitCode = 1;
+        return;
+    }
+    if (!calculationRegion) {
+        console.error((0, kleur_1.red)('Error: --region (or --aws-region) is required'));
         process.exitCode = 1;
         return;
     }
-    const cpuTimeseries = parseGcpTimeseries(opts.cpuTimeseries);
-    const ramUsedTimeseries = parseGcpTimeseries(opts.ramUsedTimeseries);
-    const ramSizeTimeseries = parseGcpTimeseries(opts.ramSizeTimeseries);
+    let cpuTimeseries = [];
+    let ramUsedTimeseries = [];
+    let ramSizeTimeseries = [];
+    const timeseriesProvided = Boolean(opts.cpuTimeseries && opts.ramUsedTimeseries && opts.ramSizeTimeseries);
+    const shouldFetchCloudWatch = provider === 'aws' && (opts.fromCloudwatch || (!timeseriesProvided && opts.awsInstanceId));
+    if (shouldFetchCloudWatch) {
+        const instanceId = opts.awsInstanceId;
+        const resolvedRegion = calculationRegion || awsEnvRegion;
+        if (!resolvedRegion || !instanceId) {
+            console.error((0, kleur_1.red)('Error: --aws-instance-id and --region/--aws-region are required for AWS provider'));
+            process.exitCode = 1;
+            return;
+        }
+        const awsInstanceId = instanceId;
+        const awsRegionValue = resolvedRegion;
+        const startTime = opts.awsStartTime
+            ? new Date(opts.awsStartTime)
+            : process.env.CI_PIPELINE_CREATED_AT
+                ? new Date(process.env.CI_PIPELINE_CREATED_AT)
+                : new Date(Date.now() - 60 * 60 * 1000);
+        const endTime = opts.awsEndTime ? new Date(opts.awsEndTime) : new Date();
+        const periodSeconds = opts.awsPeriod ? Number(opts.awsPeriod) : 60;
+        let memoryBytesFallback;
+        try {
+            const repo = new power_profile_repository_1.PowerProfileRepository(config_1.config.dataDir);
+            const profile = await repo.getMachineProfile('aws', opts.machine);
+            if (profile?.memoryGb) {
+                memoryBytesFallback = profile.memoryGb * 1024 * 1024 * 1024;
+            }
+        }
+        catch { }
+        try {
+            const cw = await (0, cloudwatch_1.fetchCloudWatchTimeseries)({
+                region: awsRegionValue,
+                instanceId: awsInstanceId,
+                startTime,
+                endTime,
+                periodSeconds,
+                memoryBytesFallback
+            });
+            cpuTimeseries = cw.cpuUtilization;
+            ramUsedTimeseries = cw.ramUsed;
+            ramSizeTimeseries = cw.ramTotal;
+            if (!ramSizeTimeseries.length && memoryBytesFallback) {
+                const ts = ramUsedTimeseries[0]?.timestamp || new Date().toISOString();
+                ramSizeTimeseries = [{ timestamp: ts, value: memoryBytesFallback }];
+            }
+        }
+        catch (errorValue) {
+            console.error((0, kleur_1.red)('Error fetching CloudWatch metrics:'), formatErrorMessage(errorValue));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else {
+        if (!timeseriesProvided) {
+            console.error((0, kleur_1.red)('Error: --cpu-timeseries, --ram-used-timeseries, and --ram-size-timeseries are required'));
+            process.exitCode = 1;
+            return;
+        }
+        cpuTimeseries = parseTimeseriesFile(opts.cpuTimeseries);
+        ramUsedTimeseries = parseTimeseriesFile(opts.ramUsedTimeseries);
+        ramSizeTimeseries = parseTimeseriesFile(opts.ramSizeTimeseries);
+    }
     console.log((0, kleur_1.gray)(`Loaded ${cpuTimeseries.length} CPU points, ${ramUsedTimeseries.length} RAM points`));
     // Sort by timestamp for charts
     const cpuSorted = [...cpuTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
     const ramSorted = [...ramUsedTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
     const ramSizeSorted = [...ramSizeTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
     // CPU chart (only if more than 1 point)
-    const cpuValues = cpuSorted.map(p => p.value * 100);
+    const cpuValues = cpuSorted.map(p => {
+        if (provider === 'aws') {
+            return p.value <= 1 ? p.value * 100 : p.value;
+        }
+        return p.value * 100;
+    });
     if (cpuValues.length > 1) {
         console.log((0, kleur_1.bold)('\nCPU Utilization (%)'));
         console.log(asciichart_1.default.plot(cpuValues, { height: 8, format: (x) => x.toFixed(1).padStart(6) }));
@@ -62,9 +232,9 @@ const runCalculate = async (opts) => {
     }
     try {
         const { result, budget, markdown } = await (0, index_1.calculate)({
-            provider: opts.provider,
+            provider,
             machineType: opts.machine,
-            region: opts.region,
+            region: calculationRegion,
             cpuTimeseries,
             ramUsedTimeseries,
             ramSizeTimeseries,
@@ -102,20 +272,26 @@ const runCalculate = async (opts) => {
             process.exitCode = 1;
         }
     }
-    catch (err) {
-        console.error((0, kleur_1.red)('Error:'), err?.message || err);
+    catch (errorValue) {
+        console.error((0, kleur_1.red)('Error:'), formatErrorMessage(errorValue));
         process.exitCode = 1;
     }
 };
 program
     .name('gitgreen')
     .description('GitGreen carbon calculator using real timeseries metrics')
-    .option('-p, --provider <provider>', 'Cloud provider (gcp)')
+    .option('-p, --provider <provider>', 'Cloud provider (gcp|aws)', config_1.config.defaultProvider)
     .option('-m, --machine <type>', 'Machine type (e.g., e2-standard-4)')
-    .option('-r, --region <region>', 'Region/zone (e.g., us-central1-a)')
-    .option('--cpu-timeseries <path>', 'Path to CPU timeseries JSON (GCP Monitoring format)')
+    .option('-r, --region <region>', 'Region/zone (e.g., us-central1-a or us-east-1)')
+    .option('--cpu-timeseries <path>', 'Path to CPU timeseries JSON (GCP Monitoring or CloudWatch)')
     .option('--ram-used-timeseries <path>', 'Path to RAM used timeseries JSON')
     .option('--ram-size-timeseries <path>', 'Path to RAM size timeseries JSON')
+    .option('--aws-instance-id <id>', 'AWS EC2 instance ID (for CloudWatch fetch)')
+    .option('--aws-region <region>', 'AWS region (overrides --region)')
+    .option('--aws-start-time <iso>', 'Custom start time (ISO) for CloudWatch metrics')
+    .option('--aws-end-time <iso>', 'Custom end time (ISO) for CloudWatch metrics')
+    .option('--aws-period <seconds>', 'CloudWatch metric period in seconds', v => Number(v))
+    .option('--from-cloudwatch', 'Fetch CPU/RAM metrics from CloudWatch (AWS only)')
     .option('--budget <grams>', 'Carbon budget in grams CO2e', v => Number(v))
     .option('--fail-on-budget', 'Exit non-zero when budget exceeded')
     .option('--out-md <path>', 'Write markdown report')

package/dist/init.js

@@ -10,6 +10,7 @@ const path_1 = __importDefault(require("path"));
 const axios_1 = __importDefault(require("axios"));
 const prompts_1 = __importDefault(require("prompts"));
 const kleur_1 = require("kleur");
+const power_profile_repository_1 = require("./lib/carbon/power-profile-repository");
 const hasGlab = () => {
     try {
         (0, child_process_1.execSync)('glab --version', { stdio: 'ignore' });
@@ -80,12 +81,19 @@ const setVariable = async (auth, project, key, value, masked = false) => {
         return setVariableApi(auth.baseUrl, auth.pat, project, key, value, masked);
     }
 };
-const generateCiJob = (opts = {}) => {
-    const { runnerTag, carbonBudget, failOnBudget } = opts;
-    let inputs = `      gcp_project_id: $GCP_PROJECT_ID
-      gcp_instance_id: $GCP_INSTANCE_ID
-      gcp_zone: $GCP_ZONE
+const generateCiJob = (opts) => {
+    const { provider, runnerTag, carbonBudget, failOnBudget } = opts;
+    let inputs = `      provider: ${provider}
       machine_type: $MACHINE_TYPE`;
+    if (provider === 'gcp') {
+        inputs += `\n      gcp_project_id: $GCP_PROJECT_ID\n      gcp_instance_id: $GCP_INSTANCE_ID\n      gcp_zone: $GCP_ZONE`;
+    }
+    else {
+        inputs += `\n      aws_region: $AWS_REGION\n      aws_instance_id: $AWS_INSTANCE_ID`;
+        if (opts.aws?.periodSeconds) {
+            inputs += `\n      aws_period_seconds: "${opts.aws.periodSeconds}"`;
+        }
+    }
     if (carbonBudget) {
         inputs += `\n      carbon_budget_grams: "${carbonBudget}"`;
     }
@@ -95,7 +103,7 @@ const generateCiJob = (opts = {}) => {
     const tagsSection = runnerTag ? `\n  tags:\n    - ${runnerTag}` : '';
     return `# GitGreen carbon analysis (generated by gitgreen init)
 include:
-  - component: gitlab.com/youneslaaroussi/gitgreen/gitgreen-cli-component@0.1.0
+  - component: gitlab.com/youneslaaroussi/gitgreen/gitgreen-cli-component@main
     inputs:
 ${inputs}
 
@@ -103,6 +111,565 @@ carbon_analysis:
   extends: .gitgreen-carbon-analysis${tagsSection}
 `;
 };
+const applyCiJobSnippet = async (ciJob) => {
+    const { addCiJob } = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'addCiJob',
+        message: 'Add job to .gitlab-ci.yml?',
+        initial: true
+    });
+    const ciPath = path_1.default.join(process.cwd(), '.gitlab-ci.yml');
+    if (addCiJob) {
+        if (fs_1.default.existsSync(ciPath)) {
+            const backupPath = `/tmp/gitlab-ci-backup-${Date.now()}.yml`;
+            const existing = fs_1.default.readFileSync(ciPath, 'utf8');
+            fs_1.default.writeFileSync(backupPath, existing);
+            console.log((0, kleur_1.gray)(`Backup saved to: ${backupPath}`));
+            fs_1.default.writeFileSync(ciPath, existing + '\n' + ciJob);
+        }
+        else {
+            fs_1.default.writeFileSync(ciPath, 'stages:\n  - test\n\n' + ciJob);
+        }
+        console.log((0, kleur_1.green)('Updated .gitlab-ci.yml'));
+    }
+    else {
+        console.log('\nCI job snippet:\n');
+        console.log(ciJob);
+    }
+};
+const getAwsMachineTypes = (() => {
+    let cached = null;
+    return () => {
+        if (cached)
+            return cached;
+        try {
+            const repo = new power_profile_repository_1.PowerProfileRepository(path_1.default.join(__dirname, '..', 'data'));
+            cached = repo.listMachines('aws');
+            return cached;
+        }
+        catch {
+            cached = [];
+            return cached;
+        }
+    };
+})();
+const promptMachineType = async (message, initial) => {
+    const machines = getAwsMachineTypes();
+    if (!machines.length) {
+        const { manualMachine } = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'manualMachine',
+            message,
+            initial
+        });
+        return manualMachine || initial;
+    }
+    const choices = [
+        ...machines.map(m => ({ title: m, value: m })),
+        { title: 'Enter manually', value: '_manual_' }
+    ];
+    const { selectedType } = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'selectedType',
+        message,
+        choices,
+        initial: Math.max(0, machines.indexOf(initial))
+    });
+    if (selectedType === '_manual_') {
+        const { manualMachine } = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'manualMachine',
+            message,
+            initial
+        });
+        return manualMachine || initial;
+    }
+    return selectedType;
+};
+const listAwsInstances = (region, env) => {
+    try {
+        const query = "Reservations[].Instances[].{InstanceId:InstanceId,Type:InstanceType,State:State.Name,Name:Tags[?Key==\\`Name\\`]|[0].Value}";
+        const raw = (0, child_process_1.execSync)(`aws ec2 describe-instances --region ${region} --query "${query}" --output json`, { encoding: 'utf8', env });
+        const parsed = JSON.parse(raw);
+        return parsed
+            .filter(item => Boolean(item.InstanceId))
+            .map(item => ({
+            instanceId: String(item.InstanceId),
+            type: item.Type,
+            state: item.State,
+            name: item.Name
+        }));
+    }
+    catch {
+        return [];
+    }
+};
+const ensureAwsCli = () => {
+    try {
+        (0, child_process_1.execSync)('aws --version', { stdio: 'ignore' });
+    }
+    catch {
+        console.log((0, kleur_1.red)('aws CLI not found. Install from https://aws.amazon.com/cli/'));
+        process.exit(1);
+    }
+};
+const resolveAmazonLinuxAmi = (region, env) => {
+    try {
+        const ami = (0, child_process_1.execSync)(`aws ssm get-parameter --name /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64 --query 'Parameter.Value' --output text --region ${region}`, { encoding: 'utf8', env }).trim();
+        if (ami)
+            return ami;
+    }
+    catch { }
+    return '';
+};
+const createRunnerToken = (auth, projectPath, description, runnerTag) => {
+    if (auth.type !== 'glab')
+        return '';
+    try {
+        const projectEncoded = encodeURIComponent(projectPath);
+        const projectInfoJson = (0, child_process_1.execSync)(`glab api "projects/${projectEncoded}"`, { encoding: 'utf8' });
+        const projectInfo = JSON.parse(projectInfoJson);
+        const projectId = projectInfo.id;
+        const createResult = (0, child_process_1.execSync)(`glab api --method POST "user/runners" -f runner_type=project_type -f project_id=${projectId} -f description="${description}" -f tag_list="${runnerTag}" -f run_untagged=true`, { encoding: 'utf8' });
+        const runnerData = JSON.parse(createResult);
+        console.log((0, kleur_1.green)(`Runner token created (ID: ${runnerData.id})`));
+        return runnerData.token;
+    }
+    catch (err) {
+        console.log((0, kleur_1.gray)('Could not create token via API, falling back to manual...'));
+        return '';
+    }
+};
+const buildAwsUserData = (params) => {
+    const { region, runnerToken, runnerName, runnerTag, machineType, periodSeconds } = params;
+    const lines = [
+        '#!/usr/bin/env bash',
+        'set -euo pipefail',
+        `REGION=${region}`,
+        `RUNNER_TOKEN="${runnerToken}"`,
+        `RUNNER_NAME="${runnerName}"`,
+        `RUNNER_TAGS="${runnerTag}"`,
+        `MACHINE_TYPE="${machineType}"`,
+        `PERIOD=${periodSeconds}`,
+        '',
+        'dnf update -y',
+        'dnf install -y amazon-cloudwatch-agent jq tar',
+        'dnf install -y curl --allowerasing',
+        'curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | bash',
+        'dnf install -y gitlab-runner',
+        'curl -fsSL https://rpm.nodesource.com/setup_20.x | bash -',
+        'dnf install -y nodejs',
+        '',
+        'INSTANCE_ID=$(curl -s http://169.254.169.254/latest/meta-data/instance-id)',
+        '',
+        "cat > /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json <<'EOF'",
+        '{',
+        '  "metrics": {',
+        '    "append_dimensions": {',
+        '      "InstanceId": "${aws:InstanceId}"',
+        '    },',
+        '    "metrics_collected": {',
+        '      "mem": {',
+        '        "measurement": ["mem_used", "mem_total", "mem_used_percent"],',
+        `        "metrics_collection_interval": ${periodSeconds}`,
+        '      },',
+        '      "cpu": {',
+        '        "measurement": ["cpu_usage_active"],',
+        `        "metrics_collection_interval": ${periodSeconds}`,
+        '      }',
+        '    }',
+        '  }',
+        '}',
+        'EOF',
+        '',
+        '/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -c file:/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json -s',
+        '',
+        'gitlab-runner register --non-interactive --url https://gitlab.com/ --token "$RUNNER_TOKEN" --executor shell --description "$RUNNER_NAME"',
+        'RUNNER_ID=$(gitlab-runner list | grep -Eo \'[^ ]+ \\(ID: [0-9]+\\)\' | grep "$RUNNER_NAME" | sed -E \'s/.*ID: ([0-9]+).*/\\1/\')',
+        'if [ -n "$RUNNER_ID" ]; then',
+        '  gitlab-runner verify --run-untagged --add --name "$RUNNER_NAME" || true',
+        '  gitlab-runner verify --tag-list "$RUNNER_TAGS" --add --name "$RUNNER_NAME" || true',
+        'fi',
+        'echo "$INSTANCE_ID" > /opt/gitlab-runner-instance-id.txt',
+        'systemctl enable amazon-cloudwatch-agent',
+        'systemctl enable gitlab-runner',
+        'systemctl start amazon-cloudwatch-agent',
+        'systemctl start gitlab-runner'
+    ];
+    return lines.join('\n');
+};
+const provisionAwsRunnerInstance = (awsEnv, params) => {
+    const userData = buildAwsUserData({
+        region: params.region,
+        runnerToken: params.runnerToken,
+        runnerName: params.runnerName,
+        runnerTag: params.runnerTag,
+        machineType: params.machineType,
+        periodSeconds: params.periodSeconds
+    });
+    const tmpFile = `/tmp/gitgreen-aws-userdata-${Date.now()}.sh`;
+    fs_1.default.writeFileSync(tmpFile, userData);
+    const tagSpec = `ResourceType=instance,Tags=[{Key=Name,Value=${params.runnerName}},{Key=gitlab-runner,Value=gitgreen}]`;
+    const subnetFlag = params.subnetId ? `--subnet-id ${params.subnetId}` : '';
+    const sgFlag = params.securityGroupId ? `--security-group-ids ${params.securityGroupId}` : '';
+    const keyFlag = params.keyName ? `--key-name ${params.keyName}` : '';
+    const iamFlag = params.iamInstanceProfile ? `--iam-instance-profile Name=${params.iamInstanceProfile}` : '';
+    try {
+        const resultJson = (0, child_process_1.execSync)(`aws ec2 run-instances --image-id ${params.amiId} --count 1 --instance-type ${params.machineType} ${subnetFlag} ${sgFlag} ${keyFlag} ${iamFlag} --user-data file://${tmpFile} --tag-specifications '${tagSpec}' --region ${params.region} --output json`, { encoding: 'utf8', env: awsEnv, stdio: ['pipe', 'pipe', 'pipe'] });
+        const parsed = JSON.parse(resultJson);
+        return parsed?.Instances?.[0]?.InstanceId || '';
+    }
+    finally {
+        fs_1.default.unlinkSync(tmpFile);
+    }
+};
+const runAwsInit = async (auth, projectPath) => {
+    console.log((0, kleur_1.gray)('\nStep 4: AWS Runner'));
+    console.log((0, kleur_1.gray)('─'.repeat(40)));
+    console.log((0, kleur_1.gray)('Provide the details for your existing GitLab runner on AWS.'));
+    console.log((0, kleur_1.gray)('Ensure CloudWatch Agent publishes mem_used and mem_total for RAM data.'));
+    const { awsRegion } = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'awsRegion',
+        message: 'AWS region (e.g., us-east-1)',
+        initial: 'us-east-1'
+    });
+    if (!awsRegion) {
+        console.log((0, kleur_1.red)('AWS region required'));
+        process.exit(1);
+    }
+    const { runnerSetup } = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'runnerSetup',
+        message: 'Runner setup',
+        choices: [
+            { title: 'Use existing runner', value: 'existing' },
+            { title: 'Provision new AWS runner', value: 'provision' }
+        ]
+    });
+    let instanceId = '';
+    let machineType = '';
+    let periodSeconds = 60;
+    let runnerTag = 'aws';
+    let pendingInstanceSelection = false;
+    if (runnerSetup === 'existing') {
+        const existingAnswers = await (0, prompts_1.default)([
+            {
+                type: 'text',
+                name: 'runnerTag',
+                message: 'Runner tag (for routing CI jobs)',
+                initial: 'aws'
+            },
+            {
+                type: 'number',
+                name: 'periodSeconds',
+                message: 'CloudWatch metrics period (seconds)',
+                initial: 60
+            }
+        ]);
+        runnerTag = existingAnswers.runnerTag || 'aws';
+        periodSeconds = existingAnswers.periodSeconds || 60;
+        machineType = await promptMachineType('Instance type', 'm5.large');
+        pendingInstanceSelection = true;
+    }
+    else {
+        ensureAwsCli();
+        const selectedMachineType = await promptMachineType('Instance type', 'm5.large');
+        const provisionAnswers = await (0, prompts_1.default)([
+            {
+                type: 'text',
+                name: 'runnerName',
+                message: 'Runner name/description',
+                initial: 'aws-carbon-runner'
+            },
+            {
+                type: 'text',
+                name: 'runnerTag',
+                message: 'Runner tag (for routing CI jobs)',
+                initial: 'aws'
+            },
+            {
+                type: 'number',
+                name: 'periodSeconds',
+                message: 'CloudWatch metrics period (seconds)',
+                initial: 60
+            },
+            {
+                type: 'text',
+                name: 'subnetId',
+                message: 'Subnet ID (optional, leave empty for default VPC)',
+                initial: ''
+            },
+            {
+                type: 'text',
+                name: 'securityGroupId',
+                message: 'Security Group ID (optional)',
+                initial: ''
+            },
+            {
+                type: 'text',
+                name: 'keyName',
+                message: 'EC2 key pair name (optional)',
+                initial: ''
+            },
+            {
+                type: 'text',
+                name: 'iamInstanceProfile',
+                message: 'IAM instance profile name (recommended for CloudWatch Agent, optional)',
+                initial: ''
+            }
+        ]);
+        machineType = selectedMachineType;
+        periodSeconds = provisionAnswers.periodSeconds || 60;
+        runnerTag = provisionAnswers.runnerTag || 'aws';
+        const runnerName = provisionAnswers.runnerName || 'aws-carbon-runner';
+        const subnetId = provisionAnswers.subnetId || '';
+        const securityGroupId = provisionAnswers.securityGroupId || '';
+        const keyName = provisionAnswers.keyName || '';
+        const iamInstanceProfile = provisionAnswers.iamInstanceProfile || '';
+        let runnerToken = createRunnerToken(auth, projectPath, runnerName, runnerTag);
+        if (!runnerToken) {
+            const { manualToken } = await (0, prompts_1.default)({
+                type: 'password',
+                name: 'manualToken',
+                message: 'GitLab runner token (glrt-...)'
+            });
+            runnerToken = manualToken;
+        }
+        if (!runnerToken) {
+            console.log((0, kleur_1.red)('Runner token required to provision.'));
+            process.exit(1);
+        }
+        // Credentials will be collected below (Step 5) before provisioning
+        const provisionConfig = {
+            runnerName,
+            runnerToken,
+            subnetId,
+            securityGroupId,
+            keyName,
+            iamInstanceProfile
+        };
+        runAwsInit._provisionConfig = provisionConfig;
+    }
+    console.log((0, kleur_1.gray)('\nStep 5: AWS Credentials'));
+    console.log((0, kleur_1.gray)('─'.repeat(40)));
+    console.log((0, kleur_1.gray)('Use an access key with CloudWatch read permissions for the runner instance.'));
+    const { accessKeyId } = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'accessKeyId',
+        message: 'AWS Access Key ID',
+        initial: process.env.AWS_ACCESS_KEY_ID || ''
+    });
+    if (!accessKeyId) {
+        console.log((0, kleur_1.red)('AWS Access Key ID required'));
+        process.exit(1);
+    }
+    const { secretAccessKey } = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'secretAccessKey',
+        message: 'AWS Secret Access Key',
+        initial: process.env.AWS_SECRET_ACCESS_KEY || ''
+    });
+    if (!secretAccessKey) {
+        console.log((0, kleur_1.red)('AWS Secret Access Key required'));
+        process.exit(1);
+    }
+    const { sessionToken } = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'sessionToken',
+        message: 'AWS Session Token (optional)',
+        initial: process.env.AWS_SESSION_TOKEN || ''
+    });
+    const awsEnv = {
+        ...process.env,
+        AWS_REGION: awsRegion,
+        AWS_DEFAULT_REGION: awsRegion,
+        AWS_ACCESS_KEY_ID: accessKeyId,
+        AWS_SECRET_ACCESS_KEY: secretAccessKey,
+        ...(sessionToken ? { AWS_SESSION_TOKEN: sessionToken } : {})
+    };
+    if (runAwsInit._provisionConfig) {
+        ensureAwsCli();
+        const cfg = runAwsInit._provisionConfig;
+        console.log((0, kleur_1.gray)('\nProvisioning AWS runner EC2 instance...'));
+        console.log((0, kleur_1.gray)('─'.repeat(40)));
+        let amiId = resolveAmazonLinuxAmi(awsRegion, awsEnv);
+        if (!amiId) {
+            const { manualAmi } = await (0, prompts_1.default)({
+                type: 'text',
+                name: 'manualAmi',
+                message: 'AMI ID (Amazon Linux 2023)',
+                initial: ''
+            });
+            amiId = manualAmi;
+        }
+        if (!amiId) {
+            console.log((0, kleur_1.red)('AMI ID required'));
+            process.exit(1);
+        }
+        let newInstanceId = '';
+        try {
+            newInstanceId = provisionAwsRunnerInstance(awsEnv, {
+                region: awsRegion,
+                amiId,
+                machineType,
+                runnerName: cfg.runnerName,
+                runnerTag,
+                runnerToken: cfg.runnerToken,
+                periodSeconds,
+                subnetId: cfg.subnetId || undefined,
+                securityGroupId: cfg.securityGroupId || undefined,
+                keyName: cfg.keyName || undefined,
+                iamInstanceProfile: cfg.iamInstanceProfile || undefined
+            });
+        }
+        catch (err) {
+            console.log((0, kleur_1.red)('Failed to create EC2 instance: ' + (err?.message || err)));
+            process.exit(1);
+        }
+        if (!newInstanceId) {
+            console.log((0, kleur_1.red)('Could not determine instance ID from run-instances output.'));
+            process.exit(1);
+        }
+        instanceId = newInstanceId;
+        console.log((0, kleur_1.green)(`Provisioned instance ${instanceId}. Runner will register shortly.`));
+    }
+    if (pendingInstanceSelection && !instanceId) {
+        ensureAwsCli();
+        const instances = listAwsInstances(awsRegion, awsEnv);
+        let chosenInstance = '_manual_';
+        if (instances.length > 0) {
+            const choices = [
+                ...instances.map(inst => ({
+                    title: `${inst.instanceId}${inst.type ? ` (${inst.type})` : ''}${inst.name ? ` - ${inst.name}` : ''}${inst.state ? ` [${inst.state}]` : ''}`,
+                    value: inst
+                })),
+                { title: 'Enter manually', value: '_manual_' }
+            ];
+            const { selectedInstance } = await (0, prompts_1.default)({
+                type: 'select',
+                name: 'selectedInstance',
+                message: 'Select EC2 runner instance',
+                choices
+            });
+            chosenInstance = selectedInstance;
+        }
+        else {
+            console.log((0, kleur_1.gray)('No EC2 instances found via AWS CLI. Please enter details manually.'));
+        }
+        if (chosenInstance === '_manual_') {
+            const { manualInstanceId } = await (0, prompts_1.default)({
+                type: 'text',
+                name: 'manualInstanceId',
+                message: 'EC2 instance ID (i-xxxxxxxx)',
+                initial: process.env.AWS_INSTANCE_ID || ''
+            });
+            instanceId = manualInstanceId;
+            machineType = await promptMachineType('Instance type', machineType || 'm5.large');
+        }
+        else {
+            instanceId = chosenInstance.instanceId;
+            machineType = chosenInstance.type || '';
+            if (!machineType) {
+                machineType = await promptMachineType('Instance type', 'm5.large');
+            }
+            else {
+                console.log((0, kleur_1.gray)(`Detected instance type: ${machineType}`));
+            }
+        }
+        if (!instanceId) {
+            console.log((0, kleur_1.red)('Instance ID required'));
+            process.exit(1);
+        }
+    }
+    console.log((0, kleur_1.gray)('\nStep 6: Electricity Maps API'));
+    console.log((0, kleur_1.gray)('─'.repeat(40)));
+    console.log((0, kleur_1.gray)('Get free key: https://api-portal.electricitymaps.com'));
+    const { electricityMapsKey } = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'electricityMapsKey',
+        message: 'Electricity Maps API Key'
+    });
+    if (!electricityMapsKey) {
+        console.log((0, kleur_1.red)('API key required'));
+        process.exit(1);
+    }
+    console.log((0, kleur_1.gray)('\nStep 7: Optional Settings'));
+    console.log((0, kleur_1.gray)('─'.repeat(40)));
+    console.log((0, kleur_1.gray)('Set a carbon budget to track emissions against a limit.'));
+    console.log((0, kleur_1.gray)('Example: 10 grams CO2e per job. Leave empty to skip.\n'));
+    const { carbonBudget } = await (0, prompts_1.default)({
+        type: 'number',
+        name: 'carbonBudget',
+        message: 'Carbon budget (grams CO2e)',
+        initial: undefined
+    });
+    let failOnBudget = false;
+    if (carbonBudget) {
+        const { shouldFail } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'shouldFail',
+            message: 'Fail CI job if over budget?',
+            initial: false
+        });
+        failOnBudget = shouldFail;
+    }
+    console.log((0, kleur_1.gray)('\nStep 8: Setting CI/CD Variables'));
+    console.log((0, kleur_1.gray)('─'.repeat(40)));
+    const variables = [
+        { key: 'AWS_ACCESS_KEY_ID', value: accessKeyId, masked: true },
+        { key: 'AWS_SECRET_ACCESS_KEY', value: secretAccessKey, masked: true },
+        { key: 'AWS_REGION', value: awsRegion, masked: false },
+        { key: 'AWS_INSTANCE_ID', value: instanceId, masked: false },
+        { key: 'MACHINE_TYPE', value: machineType, masked: false },
+        { key: 'AWS_PERIOD_SECONDS', value: String(periodSeconds || 60), masked: false },
+        { key: 'ELECTRICITY_MAPS_API_KEY', value: electricityMapsKey, masked: true }
+    ];
+    if (sessionToken) {
+        variables.push({ key: 'AWS_SESSION_TOKEN', value: sessionToken, masked: true });
+    }
+    if (carbonBudget) {
+        variables.push({ key: 'CARBON_BUDGET_GRAMS', value: String(carbonBudget), masked: false });
+    }
+    if (failOnBudget) {
+        variables.push({ key: 'FAIL_ON_BUDGET', value: 'true', masked: false });
+    }
+    for (const v of variables) {
+        const ok = await setVariable(auth, projectPath, v.key, v.value, v.masked);
+        if (ok) {
+            console.log((0, kleur_1.green)('  Set ' + v.key));
+        }
+        else {
+            console.log((0, kleur_1.red)('  Failed: ' + v.key));
+        }
+    }
+    console.log((0, kleur_1.gray)('\nStep 9: CI Configuration'));
+    console.log((0, kleur_1.gray)('─'.repeat(40)));
+    let runnerTagForCi = runnerTag;
+    if (!runnerTagForCi) {
+        const { runnerTag: promptRunnerTag } = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'runnerTag',
+            message: 'Runner tag (leave empty for any runner)',
+            initial: 'aws'
+        });
+        runnerTagForCi = promptRunnerTag || '';
+    }
+    else {
+        console.log((0, kleur_1.gray)(`Using runner tag: ${runnerTagForCi}`));
+    }
+    const ciJob = generateCiJob({
+        provider: 'aws',
+        machineType,
+        runnerTag: runnerTagForCi || undefined,
+        carbonBudget: carbonBudget || undefined,
+        failOnBudget,
+        aws: { region: awsRegion, instanceId, periodSeconds: periodSeconds || 60 }
+    });
+    await applyCiJobSnippet(ciJob);
+    console.log((0, kleur_1.bold)('\nDone'));
+    console.log('Commit and push to trigger the pipeline.\n');
+};
 const runInit = async (opts = {}) => {
     console.log((0, kleur_1.bold)('\nGitGreen Setup\n'));
     // Step 1: GitLab Authentication
@@ -167,11 +734,12 @@ const runInit = async (opts = {}) => {
         ]
     });
     if (provider === 'aws') {
-        console.log((0, kleur_1.red)('\nAWS support coming soon.'));
-        process.exit(1);
+        await runAwsInit(auth, projectPath);
+        return;
     }
     if (provider === 'manual') {
         console.log((0, kleur_1.red)('\nManual configuration coming soon.'));
+        console.log((0, kleur_1.gray)('Docs: https://gitlab.com/youneslaaroussi/gitgreen (README covers manual metrics/power profile ingestion)'));
         process.exit(1);
     }
     // Check if gcloud is available
@@ -236,14 +804,9 @@ const runInit = async (opts = {}) => {
         message: 'GitLab Runner',
         choices: [
             { title: 'Use existing runner', value: 'existing' },
-            { title: 'Provision new GCP runner VM', value: 'provision-gcp' },
-            { title: 'Provision new AWS runner (coming soon)', value: 'provision-aws' }
+            { title: 'Provision new GCP runner VM', value: 'provision-gcp' }
         ]
     });
-    if (runnerSetup === 'provision-aws') {
-        console.log((0, kleur_1.red)('\nAWS runner provisioning coming soon.'));
-        process.exit(1);
-    }
     let gcpZone = '';
     let gcpInstanceId = '';
     let machineType = '';
@@ -688,36 +1251,15 @@ systemctl start gitlab-runner
     else {
         console.log((0, kleur_1.gray)(`Using runner tag: ${runnerTag}`));
     }
-    const { addCiJob } = await (0, prompts_1.default)({
-        type: 'confirm',
-        name: 'addCiJob',
-        message: 'Add job to .gitlab-ci.yml?',
-        initial: true
-    });
     const ciJob = generateCiJob({
+        provider: 'gcp',
+        machineType,
         runnerTag: runnerTag || undefined,
         carbonBudget: carbonBudget || undefined,
-        failOnBudget
+        failOnBudget,
+        gcp: { projectId: gcpProjectId, zone: gcpZone, instanceId: gcpInstanceId }
     });
-    if (addCiJob) {
-        const ciPath = path_1.default.join(process.cwd(), '.gitlab-ci.yml');
-        if (fs_1.default.existsSync(ciPath)) {
-            // Backup existing file before modifying
-            const backupPath = `/tmp/gitlab-ci-backup-${Date.now()}.yml`;
-            const existing = fs_1.default.readFileSync(ciPath, 'utf8');
-            fs_1.default.writeFileSync(backupPath, existing);
-            console.log((0, kleur_1.gray)(`Backup saved to: ${backupPath}`));
-            fs_1.default.writeFileSync(ciPath, existing + '\n' + ciJob);
-        }
-        else {
-            fs_1.default.writeFileSync(ciPath, 'stages:\n  - test\n\n' + ciJob);
-        }
-        console.log((0, kleur_1.green)('Updated .gitlab-ci.yml'));
-    }
-    else {
-        console.log('\nCI job snippet:\n');
-        console.log(ciJob);
-    }
+    await applyCiJobSnippet(ciJob);
     console.log((0, kleur_1.bold)('\nDone'));
     console.log('Commit and push to trigger the pipeline.\n');
 };

package/dist/lib/aws/cloudwatch.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCloudWatchTimeseries = void 0;
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const toTimeseries = (result) => {
+    if (!result)
+        return [];
+    const timestamps = result.Timestamps || [];
+    const values = result.Values || [];
+    const points = [];
+    const len = Math.min(timestamps.length, values.length);
+    for (let i = 0; i < len; i++) {
+        const value = values[i];
+        if (value === undefined || value === null)
+            continue;
+        const ts = timestamps[i];
+        points.push({
+            timestamp: ts instanceof Date ? ts.toISOString() : new Date(ts).toISOString(),
+            value: Number(value)
+        });
+    }
+    return points.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+};
+const fetchCloudWatchTimeseries = async (opts) => {
+    const cw = new client_cloudwatch_1.CloudWatchClient({ region: opts.region });
+    const periodSeconds = opts.periodSeconds ?? 60;
+    const command = new client_cloudwatch_1.GetMetricDataCommand({
+        StartTime: opts.startTime,
+        EndTime: opts.endTime,
+        ScanBy: 'TimestampAscending',
+        MetricDataQueries: [
+            {
+                Id: 'cpu',
+                MetricStat: {
+                    Metric: {
+                        Namespace: 'AWS/EC2',
+                        MetricName: 'CPUUtilization',
+                        Dimensions: [{ Name: 'InstanceId', Value: opts.instanceId }]
+                    },
+                    Period: periodSeconds,
+                    Stat: 'Average'
+                },
+                ReturnData: true
+            },
+            {
+                Id: 'ramUsed',
+                MetricStat: {
+                    Metric: {
+                        Namespace: 'CWAgent',
+                        MetricName: 'mem_used',
+                        Dimensions: [{ Name: 'InstanceId', Value: opts.instanceId }]
+                    },
+                    Period: periodSeconds,
+                    Stat: 'Average'
+                },
+                ReturnData: true
+            },
+            {
+                Id: 'ramTotal',
+                MetricStat: {
+                    Metric: {
+                        Namespace: 'CWAgent',
+                        MetricName: 'mem_total',
+                        Dimensions: [{ Name: 'InstanceId', Value: opts.instanceId }]
+                    },
+                    Period: periodSeconds,
+                    Stat: 'Average'
+                },
+                ReturnData: true
+            },
+            {
+                Id: 'ramUsedPercent',
+                MetricStat: {
+                    Metric: {
+                        Namespace: 'CWAgent',
+                        MetricName: 'mem_used_percent',
+                        Dimensions: [{ Name: 'InstanceId', Value: opts.instanceId }]
+                    },
+                    Period: periodSeconds,
+                    Stat: 'Average'
+                },
+                ReturnData: true
+            }
+        ]
+    });
+    const resp = await cw.send(command);
+    const byId = new Map();
+    (resp.MetricDataResults || []).forEach(result => {
+        if (result.Id)
+            byId.set(result.Id, result);
+    });
+    const cpuUtilization = toTimeseries(byId.get('cpu'));
+    const ramUsed = toTimeseries(byId.get('ramUsed'));
+    let ramTotal = toTimeseries(byId.get('ramTotal'));
+    const ramUsedPercent = toTimeseries(byId.get('ramUsedPercent'));
+    let ramUsedSeries = ramUsed;
+    const fallbackTotal = ramTotal[0]?.value || opts.memoryBytesFallback;
+    if (!ramUsedSeries.length && ramUsedPercent.length && fallbackTotal) {
+        ramUsedSeries = ramUsedPercent.map(point => ({
+            timestamp: point.timestamp,
+            value: (point.value / 100) * fallbackTotal
+        }));
+    }
+    if (!ramTotal.length && fallbackTotal) {
+        const ts = ramUsedSeries[0]?.timestamp || new Date().toISOString();
+        ramTotal = [{ timestamp: ts, value: fallbackTotal }];
+    }
+    return { cpuUtilization, ramUsed: ramUsedSeries, ramTotal };
+};
+exports.fetchCloudWatchTimeseries = fetchCloudWatchTimeseries;

package/dist/lib/carbon/carbon-calculator.js

@@ -36,17 +36,19 @@ class CarbonCalculator {
         const cpuSorted = [...job.cpuTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
         const ramUsedSorted = [...job.ramUsedTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
         const ramSizeSorted = [...job.ramSizeTimeseries].sort((a, b) => this.parseTimestamp(a.timestamp) - this.parseTimestamp(b.timestamp));
-        // GCP reports metrics every 60 seconds
-        const GCP_INTERVAL_SECONDS = 60;
+        const DEFAULT_INTERVAL_SECONDS = 60;
         // Integrate CPU energy over timeseries
         let cpuEnergyKwh = 0;
         for (let i = 0; i < cpuSorted.length; i++) {
-            const cpuPercent = cpuSorted[i].value * 100; // GCP returns 0-1, convert to 0-100
+            const rawCpuValue = cpuSorted[i].value;
+            const cpuPercent = job.provider === 'aws'
+                ? (rawCpuValue <= 1 ? rawCpuValue * 100 : rawCpuValue)
+                : rawCpuValue * 100;
             const powerWatts = this.interpolatePower(cpuProfile, cpuPercent);
             // Calculate interval from timestamps, or use GCP interval for single point
             let intervalSeconds;
             if (cpuSorted.length === 1) {
-                intervalSeconds = GCP_INTERVAL_SECONDS;
+                intervalSeconds = DEFAULT_INTERVAL_SECONDS;
             }
             else if (i < cpuSorted.length - 1) {
                 intervalSeconds = this.parseTimestamp(cpuSorted[i + 1].timestamp) - this.parseTimestamp(cpuSorted[i].timestamp);
@@ -65,7 +67,7 @@ class CarbonCalculator {
             const powerWatts = ramUsedGb * RAM_WATTS_PER_GB;
             let intervalSeconds;
             if (ramUsedSorted.length === 1) {
-                intervalSeconds = GCP_INTERVAL_SECONDS;
+                intervalSeconds = DEFAULT_INTERVAL_SECONDS;
             }
             else if (i < ramUsedSorted.length - 1) {
                 intervalSeconds = this.parseTimestamp(ramUsedSorted[i + 1].timestamp) - this.parseTimestamp(ramUsedSorted[i].timestamp);
@@ -78,8 +80,8 @@ class CarbonCalculator {
         // Calculate total runtime from timeseries
         const firstTs = Math.min(cpuSorted.length > 0 ? this.parseTimestamp(cpuSorted[0].timestamp) : Infinity, ramUsedSorted.length > 0 ? this.parseTimestamp(ramUsedSorted[0].timestamp) : Infinity);
         const lastTs = Math.max(cpuSorted.length > 0 ? this.parseTimestamp(cpuSorted[cpuSorted.length - 1].timestamp) : 0, ramUsedSorted.length > 0 ? this.parseTimestamp(ramUsedSorted[ramUsedSorted.length - 1].timestamp) : 0);
-        // If single point, use GCP interval; otherwise use actual span
-        const runtimeSeconds = lastTs === firstTs ? GCP_INTERVAL_SECONDS : (lastTs - firstTs);
+        // If single point, use default interval; otherwise use actual span
+        const runtimeSeconds = lastTs === firstTs ? DEFAULT_INTERVAL_SECONDS : (lastTs - firstTs);
         const runtimeHours = runtimeSeconds / 3600;
         // Calculate emissions
         const cpuEmissions = cpuEnergyKwh * pue * carbonIntensity;

package/dist/lib/gitlab/report-formatter.js

@@ -64,7 +64,12 @@ const buildMarkdownReport = (result, job, budget) => {
     }
     // Add CPU chart (only if more than 1 point)
     if (cpuSorted.length > 1) {
-        const cpuValues = cpuSorted.map(p => p.value * 100);
+        const cpuValues = cpuSorted.map(p => {
+            if (job.provider === 'aws') {
+                return p.value <= 1 ? p.value * 100 : p.value;
+            }
+            return p.value * 100;
+        });
         lines.push('', '## CPU Utilization (%)', '```', asciichart_1.default.plot(cpuValues, { height: 6 }), '```');
     }
     // Add RAM chart (only if more than 1 point)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitgreen",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "GitGreen CLI for carbon reporting in GitLab pipelines (GCP/AWS)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",