duoops 0.0.0

package/dist/commands/measure/calculate.js

@@ -0,0 +1,208 @@
+import { Command, Flags } from '@oclif/core';
+import asciichart from 'asciichart';
+import { bold, gray, green, red } from 'kleur/colors';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { configManager } from '../../lib/config.js';
+import { persistJobToBigQuery } from '../../lib/integrations/bigquery-sink.js';
+import { CarbonCalculator } from '../../lib/measure/carbon-calculator.js';
+import { parseTimeseriesFile } from '../../lib/measure/cli-utils.js';
+import { IntensityProvider } from '../../lib/measure/intensity-provider.js';
+import { PowerProfileRepository } from '../../lib/measure/power-profile-repository.js';
+import { ZoneMapper } from '../../lib/measure/zone-mapper.js';
+export default class CarbonCalculate extends Command {
+    static args = {
+    // none for now
+    };
+    static description = 'Calculate carbon emissions from CPU/RAM timeseries';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --provider gcp --machine e2-standard-4 --region us-central1 --cpu cpu.json --ram-used ram_used.json`,
+    ];
+    static flags = {
+        budget: Flags.integer({
+            description: 'Carbon budget in grams CO2e',
+        }),
+        'cpu-timeseries': Flags.string({
+            description: 'Path to CPU timeseries JSON',
+            required: true,
+        }),
+        'fail-on-budget': Flags.boolean({
+            default: false,
+            description: 'Exit with error if budget exceeded',
+        }),
+        machine: Flags.string({
+            char: 'm',
+            description: 'Machine type (e.g., e2-standard-4)',
+            required: true,
+        }),
+        'out-json': Flags.string({
+            description: 'Path to write JSON report',
+        }),
+        'out-md': Flags.string({
+            description: 'Path to write Markdown report',
+        }),
+        provider: Flags.string({
+            char: 'p',
+            default: 'gcp',
+            description: 'Cloud provider',
+            options: ['gcp', 'aws'], // Keeping aws in options but functionality limited
+        }),
+        'ram-size-timeseries': Flags.string({
+            description: 'Path to RAM size timeseries JSON',
+            required: false,
+        }),
+        'ram-used-timeseries': Flags.string({
+            description: 'Path to RAM used timeseries JSON',
+            required: true,
+        }),
+        region: Flags.string({
+            char: 'r',
+            description: 'Region (e.g., us-central1)',
+            required: true,
+        }),
+    };
+    // eslint-disable-next-line complexity -- carbon report has many branches
+    async run() {
+        const { flags } = await this.parse(CarbonCalculate);
+        // Parse timeseries
+        const cpuTimeseries = parseTimeseriesFile(flags['cpu-timeseries']);
+        const ramUsedTimeseries = parseTimeseriesFile(flags['ram-used-timeseries']);
+        const ramSizeTimeseries = flags['ram-size-timeseries']
+            ? parseTimeseriesFile(flags['ram-size-timeseries'])
+            : [];
+        if (cpuTimeseries.length === 0) {
+            this.error('No valid data points found in CPU timeseries file');
+        }
+        if (ramUsedTimeseries.length === 0) {
+            this.error('No valid data points found in RAM used timeseries file');
+        }
+        this.log(gray(`Loaded ${cpuTimeseries.length} CPU points, ${ramUsedTimeseries.length} RAM points`));
+        // Initialize dependencies
+        // Locate data directory relative to the compiled file or project root
+        // In production (dist), __dirname is .../dist/commands/carbon
+        // data is at .../data
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        // Try to resolve data directory
+        // 1. From source (development)
+        // 2. From dist (production/built)
+        let dataDir = path.resolve(__dirname, '../../../../data');
+        if (!fs.existsSync(dataDir)) {
+            // Fallback for different structures or if run from different location
+            dataDir = path.resolve(process.cwd(), 'data');
+        }
+        if (!fs.existsSync(dataDir)) {
+            this.error(`Could not locate data directory at ${dataDir}`);
+        }
+        const powerProfileRepository = new PowerProfileRepository(dataDir);
+        const zoneMapper = new ZoneMapper(dataDir);
+        // Using a placeholder API key or env var if we had one, but IntensityProvider might work without it for public data or fallback
+        const intensityProvider = new IntensityProvider();
+        const calculator = new CarbonCalculator(powerProfileRepository, zoneMapper, intensityProvider);
+        const jobInput = {
+            cpuTimeseries,
+            machineType: flags.machine,
+            provider: flags.provider,
+            ramSizeTimeseries,
+            ramUsedTimeseries,
+            region: flags.region,
+        };
+        // Sort for charts
+        const cpuSorted = [...cpuTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const ramSorted = [...ramUsedTimeseries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        // CPU Chart
+        const cpuValues = cpuSorted.map((p) => {
+            if (flags.provider === 'aws') {
+                return p.value <= 1 ? p.value * 100 : p.value;
+            }
+            return p.value * 100;
+        });
+        if (cpuValues.length > 1) {
+            this.log(bold('\nCPU Utilization (%)'));
+            this.log(asciichart.plot(cpuValues, { format: (x) => x.toFixed(1).padStart(6), height: 8 }));
+        }
+        // Calculate
+        try {
+            const result = await calculator.calculate(jobInput);
+            const totalEnergyWh = (result.cpuEnergyKwh + result.ramEnergyKwh) * 1000;
+            const emissionsGrams = result.totalEmissions;
+            this.log(bold('\nCarbon Report'));
+            this.log(gray('------------------------------'));
+            this.log(`Provider: ${result.provider.toUpperCase()}`);
+            this.log(`Region:   ${result.region}`);
+            this.log(`Machine:  ${result.machineType}`);
+            this.log(`Runtime:  ${(result.runtimeHours * 3600).toFixed(0)}s`);
+            this.log(`Energy:   ${totalEnergyWh.toFixed(3)} Wh`);
+            let statusColor = green;
+            let budgetMsg = '';
+            if (flags.budget) {
+                if (emissionsGrams > flags.budget) {
+                    statusColor = red;
+                    budgetMsg = ` (over budget of ${flags.budget} g)`;
+                }
+                else {
+                    budgetMsg = ` (within budget of ${flags.budget} g)`;
+                }
+            }
+            this.log(`Total:    ${statusColor(emissionsGrams.toFixed(3) + ' gCO2e')}${budgetMsg}`);
+            this.log(`Intensity: ${result.carbonIntensity} gCO2e/kWh`);
+            this.log(`PUE:      ${result.pue}`);
+            // Persist to BigQuery if configured
+            const config = configManager.get();
+            if (config.measure?.bigqueryDataset && config.measure?.bigqueryTable) {
+                try {
+                    await persistJobToBigQuery({
+                        budget: {
+                            budgetConfigured: Boolean(flags.budget),
+                            limitGrams: flags.budget,
+                            overBudget: Boolean(flags.budget) && result.totalEmissions > (flags.budget || 0),
+                        },
+                        jobInput,
+                        jsonReport: {
+                            // Replicate basic JSON structure
+                            emissions: result,
+                            job: jobInput,
+                            provider: result.provider,
+                        },
+                        result,
+                    }, {
+                        dataset: config.measure.bigqueryDataset,
+                        table: config.measure.bigqueryTable,
+                    });
+                    this.log(gray(`Persisted results to BigQuery (${config.measure.bigqueryDataset}.${config.measure.bigqueryTable})`));
+                }
+                catch (error) {
+                    this.warn(`Failed to persist to BigQuery: ${error}`);
+                }
+            }
+            // Output files
+            if (flags['out-json']) {
+                fs.writeFileSync(flags['out-json'], JSON.stringify(result, null, 2));
+                this.log(gray(`JSON report written to ${flags['out-json']}`));
+            }
+            if (flags['out-md']) {
+                const md = `
+# Carbon Emission Report
+
+| Metric | Value |
+| :--- | :--- |
+| Provider | ${result.provider} |
+| Region | ${result.region} |
+| Machine | ${result.machineType} |
+| **Total Emissions** | **${emissionsGrams.toFixed(3)} gCO2e** |
+| Energy Usage | ${totalEnergyWh.toFixed(3)} Wh |
+| Runtime | ${(result.runtimeHours * 3600).toFixed(0)}s |
+`;
+                fs.writeFileSync(flags['out-md'], md);
+                this.log(gray(`Markdown report written to ${flags['out-md']}`));
+            }
+            if (flags.budget && emissionsGrams > flags.budget && flags['fail-on-budget']) {
+                this.error(`Carbon budget exceeded: ${emissionsGrams.toFixed(3)}g > ${flags.budget}g`, { exit: 1 });
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/commands/measure/component.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@oclif/core';
+export default class MeasureComponent extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/measure/component.js

@@ -0,0 +1,23 @@
+import { Command } from '@oclif/core';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export default class MeasureComponent extends Command {
+    static description = 'Output the GitLab CI component configuration';
+    async run() {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        // Locate the template file
+        // In dev: src/commands/measure/../../templates/duoops-measure-component.yml -> root/templates/...
+        // In dist: dist/commands/measure/../../templates/duoops-measure-component.yml -> root/templates/...
+        let templatePath = path.resolve(__dirname, '../../../../templates/duoops-measure-component.yml');
+        if (!fs.existsSync(templatePath)) {
+            // Fallback relative to CWD if running from source root
+            templatePath = path.resolve(process.cwd(), 'templates/duoops-measure-component.yml');
+        }
+        if (!fs.existsSync(templatePath)) {
+            this.error(`Could not locate component template at ${templatePath}`);
+        }
+        const content = fs.readFileSync(templatePath, 'utf8');
+        this.log(content);
+    }
+}

package/dist/commands/measure/seed.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@oclif/core';
+export default class Seed extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/measure/seed.js

@@ -0,0 +1,62 @@
+import { BigQuery } from '@google-cloud/bigquery';
+import { Command } from '@oclif/core';
+import { configManager } from '../../lib/config.js';
+export default class Seed extends Command {
+    static description = 'Seed the BigQuery emissions table with sample data for testing';
+    async run() {
+        const config = configManager.get();
+        if (!config.measure?.bigqueryDataset || !config.measure?.bigqueryTable) {
+            this.error('BigQuery not configured. Run "duoops init" first.');
+        }
+        const projectId = config.measure.googleProjectId || process.env.GCP_PROJECT_ID;
+        if (!projectId) {
+            this.error('Google Cloud Project ID is missing from configuration.');
+        }
+        const bigquery = new BigQuery({ projectId });
+        const datasetId = config.measure.bigqueryDataset;
+        const tableId = config.measure.bigqueryTable;
+        this.log(`Seeding data into ${datasetId}.${tableId}...`);
+        const rows = [];
+        const now = new Date();
+        // Generate 50 sample entries over the last 5 days
+        for (let i = 0; i < 50; i++) {
+            const date = new Date(now.getTime() - i * 4 * 60 * 60 * 1000); // Every 4 hours
+            // Randomize values somewhat realistically
+            const runtime = 120 + Math.random() * 300; // 2-7 minutes
+            const cpu = 0.4 + Math.random() * 0.5; // 40-90% CPU
+            const ram = 0.3 + Math.random() * 0.4; // 30-70% RAM
+            // Rough estimation: 
+            // e2-standard-4 (4 vCPU, 16GB RAM)
+            // ~150W max power? Let's say 0.04 kWh per hour
+            const energy = (runtime / 3600) * (0.1 + (cpu * 0.1)); // kWh
+            const emissions = energy * 400; // ~400g CO2/kWh global avg
+            rows.push({
+                /* eslint-disable camelcase -- BigQuery schema uses snake_case */
+                cpu_utilization_avg: Number(cpu.toFixed(4)),
+                energy_kwh: Number(energy.toFixed(6)),
+                gitlab_job_id: 1_000_000 + i,
+                gitlab_job_name: i % 3 === 0 ? 'build-job' : i % 3 === 1 ? 'test-job' : 'deploy-job',
+                gitlab_project_id: config.defaultProjectId ? Number(config.defaultProjectId) : 12_345,
+                gitlab_user_name: 'dev-user',
+                ingested_at: bigquery.timestamp(date),
+                machine_type: 'e2-standard-4',
+                ram_utilization_avg: Number(ram.toFixed(4)),
+                region: 'us-central1',
+                runtime_seconds: Number(runtime.toFixed(2)),
+                total_emissions_g: Number(emissions.toFixed(4)),
+                /* eslint-enable camelcase */
+            });
+        }
+        try {
+            await bigquery
+                .dataset(datasetId)
+                .table(tableId)
+                .insert(rows);
+            this.log(`Successfully inserted ${rows.length} rows of sample data.`);
+            this.log('Check the Portal Metrics tab to visualize it!');
+        }
+        catch (error) {
+            this.error(`Failed to insert data: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/commands/pipelines/list.d.ts

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

package/dist/commands/pipelines/list.js

@@ -0,0 +1,62 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { configManager } from '../../lib/config.js';
+import { getPipelineProvider } from '../../lib/gitlab/index.js';
+export default class PipelinesList extends Command {
+    static args = {
+        project: Args.string({
+            description: 'Project ID or path (e.g. group/project)',
+            required: false,
+        }),
+    };
+    static description = 'List GitLab CI pipelines for a project';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> group/my-project`,
+        `<%= config.bin %> <%= command.id %> 123 --limit 20 --ref main`,
+    ];
+    static flags = {
+        limit: Flags.integer({
+            char: 'n',
+            default: 10,
+            description: 'Maximum number of pipelines to return',
+        }),
+        ref: Flags.string({
+            description: 'Filter by branch or tag',
+        }),
+        status: Flags.string({
+            description: 'Filter by status (created, pending, running, success, failed, canceled, skipped, manual, scheduled)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PipelinesList);
+        const provider = getPipelineProvider();
+        const config = configManager.get();
+        const projectId = args.project || config.defaultProjectId;
+        if (!projectId) {
+            this.error('Project ID is required. Provide it as an argument or set DUOOPS_TEST_PROJECT_ID in .env');
+        }
+        const pipelines = await provider.listPipelines(projectId, {
+            perPage: flags.limit,
+            ref: flags.ref,
+            status: flags.status,
+        });
+        if (pipelines.length === 0) {
+            this.log('No pipelines found.');
+            return;
+        }
+        const rows = pipelines.map((p) => [
+            String(p.id),
+            p.ref,
+            p.status,
+            p.sha.slice(0, 8),
+            new Date(p.createdAt).toLocaleString(),
+        ]);
+        const colWidths = [12, 15, 12, 10, 25];
+        const header = ['ID', 'Ref', 'Status', 'SHA', 'Created'].map((h, i) => h.padEnd(colWidths[i] ?? 0));
+        this.log(header.join(' '));
+        this.log('-'.repeat(header.join(' ').length));
+        for (const row of rows) {
+            const line = row.map((cell, i) => String(cell).slice(0, colWidths[i] ?? 0).padEnd(colWidths[i] ?? 0));
+            this.log(line.join(' '));
+        }
+    }
+}

package/dist/commands/pipelines/show.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class PipelinesShow extends Command {
+    static args: {
+        project: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        pipeline_id: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/pipelines/show.js

@@ -0,0 +1,68 @@
+import { Args, Command } from '@oclif/core';
+import { getPipelineProvider } from '../../lib/gitlab/index.js';
+export default class PipelinesShow extends Command {
+    static args = {
+        /* eslint-disable perfectionist/sort-objects -- project must be first for CLI arg order */
+        project: Args.string({
+            description: 'Project ID (e.g. 123456)',
+            async parse(input) {
+                if (/^\d+$/.test(input)) {
+                    return input;
+                }
+                throw new Error('Project ID must be a numeric ID (e.g. 123456). Project paths are not currently supported by this command.');
+            },
+            required: true,
+        }),
+        pipeline_id: Args.integer({
+            description: 'Pipeline ID',
+            required: true,
+        }),
+        /* eslint-enable perfectionist/sort-objects */
+    };
+    static description = 'Show pipeline details and jobs';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> 12345 67890`,
+    ];
+    async run() {
+        const { args } = await this.parse(PipelinesShow);
+        const provider = getPipelineProvider();
+        const [pipeline, jobs] = await Promise.all([
+            provider.getPipeline(args.project, args.pipeline_id),
+            provider.listJobs(args.project, args.pipeline_id),
+        ]);
+        this.log('');
+        this.log('Pipeline');
+        this.log('  ID:       ', String(pipeline.id));
+        this.log('  Ref:      ', pipeline.ref);
+        this.log('  SHA:      ', pipeline.sha);
+        this.log('  Status:   ', pipeline.status);
+        if (pipeline.duration !== undefined && pipeline.duration !== null) {
+            this.log('  Duration: ', `${pipeline.duration}s`);
+        }
+        this.log('  Created:  ', pipeline.createdAt);
+        if (pipeline.webUrl) {
+            this.log('  URL:      ', pipeline.webUrl);
+        }
+        this.log('');
+        this.log('Jobs');
+        if (jobs.length === 0) {
+            this.log('  (no jobs)');
+            return;
+        }
+        const colWidths = [6, 25, 12, 12, 10];
+        const header = ['ID', 'Name', 'Stage', 'Status', 'Duration'].map((h, i) => h.padEnd(colWidths[i] ?? 0));
+        this.log('  ' + header.join(' '));
+        this.log('  ' + '-'.repeat(header.join(' ').length));
+        for (const j of jobs) {
+            const duration = j.duration === undefined || j.duration === null ? '-' : `${j.duration}s`;
+            const line = [
+                String(j.id).padEnd(colWidths[0] ?? 0),
+                j.name.slice(0, (colWidths[1] ?? 0) - 1).padEnd(colWidths[1] ?? 0),
+                j.stage.slice(0, (colWidths[2] ?? 0) - 1).padEnd(colWidths[2] ?? 0),
+                j.status.padEnd(colWidths[3] ?? 0),
+                duration.padEnd(colWidths[4] ?? 0),
+            ];
+            this.log('  ' + line.join(' '));
+        }
+    }
+}

package/dist/commands/portal.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Portal extends Command {
+    static description: string;
+    static flags: {
+        port: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/portal.js

@@ -0,0 +1,139 @@
+import { Command, Flags } from '@oclif/core';
+import { convertToModelMessages } from 'ai';
+import cors from 'cors';
+import express from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import open from 'open';
+import { streamAgent } from '../lib/ai/agent.js';
+import { configManager } from '../lib/config.js';
+import { fetchAvailableProjects, fetchCarbonMetrics } from '../lib/measure/bigquery-service.js';
+export default class Portal extends Command {
+    static description = 'Launch the DuoOps web portal';
+    static flags = {
+        port: Flags.integer({
+            char: 'p',
+            default: 3000,
+            description: 'Port to run the portal on',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Portal);
+        const app = express();
+        const { port } = flags;
+        app.use(cors());
+        app.use(express.json());
+        // API Routes – streaming chat (AI SDK UI protocol: tool steps, text stream)
+        /* eslint-disable max-depth -- stream consumer adds necessary nesting */
+        app.post('/api/chat', async (req, res) => {
+            try {
+                const { messages } = req.body;
+                if (!messages || !Array.isArray(messages)) {
+                    res.status(400).json({ error: 'Messages array is required' });
+                    return;
+                }
+                const modelMessages = await convertToModelMessages(messages);
+                const result = streamAgent(modelMessages);
+                const response = result.toUIMessageStreamResponse();
+                res.status(response.status);
+                for (const [k, v] of response.headers.entries())
+                    res.setHeader(k, v);
+                if (response.body) {
+                    const reader = response.body.getReader();
+                    try {
+                        /* eslint-disable no-await-in-loop -- stream consumer requires await in loop */
+                        for (;;) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            res.write(Buffer.from(value));
+                        }
+                        /* eslint-enable no-await-in-loop */
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                }
+                res.end();
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        /* eslint-enable max-depth */
+        app.get('/api/projects', async (req, res) => {
+            try {
+                const projects = await fetchAvailableProjects();
+                res.json(projects);
+            }
+            catch (error) {
+                if (String(error).includes('not configured')) {
+                    res.json([]);
+                    return;
+                }
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/metrics', async (req, res) => {
+            try {
+                const { projectId } = req.query;
+                if (!projectId) {
+                    res.status(400).json({ error: 'Project ID is required' });
+                    return;
+                }
+                const metrics = await fetchCarbonMetrics(String(projectId), 50);
+                res.json(metrics);
+            }
+            catch (error) {
+                // If not configured, return empty array instead of crashing UI
+                if (String(error).includes('not configured')) {
+                    res.json([]);
+                    return;
+                }
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/status', (req, res) => {
+            const config = configManager.get();
+            const aiProvider = process.env.DUOOPS_AI_PROVIDER || 'gitlab';
+            const bigqueryActive = Boolean(config.measure?.bigqueryDataset && config.measure?.bigqueryTable);
+            res.json({
+                aiProvider,
+                bigqueryActive,
+            });
+        });
+        // Serve Static Files (Frontend)
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        // Try resolving relative to the compiled command file (dist/commands/portal.js)
+        // We expect the build script to copy portal/dist to dist/portal
+        let staticPath = path.resolve(__dirname, '../portal');
+        // Fallback for development (running from source)
+        if (!fs.existsSync(staticPath)) {
+            staticPath = path.resolve(process.cwd(), 'portal/dist');
+        }
+        if (!fs.existsSync(staticPath)) {
+            this.warn(`Could not find portal frontend at ${staticPath}. Did you run 'pnpm build'?`);
+        }
+        app.use(express.static(staticPath));
+        // SPA Fallback - using simple middleware for Express 5 compat
+        app.use((req, res, next) => {
+            // Only serve index.html for GET requests that are NOT API calls
+            // and accept HTML (browser navigation)
+            if (req.method === 'GET' && !req.path.startsWith('/api') && req.accepts('html')) {
+                res.sendFile(path.join(staticPath, 'index.html'));
+            }
+            else {
+                next();
+            }
+        });
+        app.listen(port, async () => {
+            const url = `http://localhost:${port}`;
+            this.log(`🚀 DuoOps Portal running at ${url}`);
+            await open(url);
+        });
+    }
+}

package/dist/commands/undo.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@oclif/core';
+export default class Undo extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/undo.js

@@ -0,0 +1,35 @@
+import { Command } from '@oclif/core';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { getLatestPatch, PATCHES_DIR } from '../lib/state.js';
+const execAsync = promisify(exec);
+export default class Undo extends Command {
+    static description = 'Undo the last edit performed by DuoOps';
+    async run() {
+        const latestPatch = getLatestPatch();
+        if (!latestPatch) {
+            this.log('No recent patches found to undo.');
+            return;
+        }
+        this.log(`Undoing changes from ${path.basename(latestPatch)}...`);
+        try {
+            // Reverse apply the patch
+            // -R = reverse
+            // --allow-empty = in case file state is weird, but usually not needed
+            await execAsync(`git apply -R "${latestPatch}"`);
+            // Move patch to 'reverted' folder for audit
+            const revertedDir = path.join(PATCHES_DIR, 'reverted');
+            if (!fs.existsSync(revertedDir)) {
+                fs.mkdirSync(revertedDir, { recursive: true });
+            }
+            const destPath = path.join(revertedDir, path.basename(latestPatch));
+            fs.renameSync(latestPatch, destPath);
+            this.log('Successfully reverted changes.');
+        }
+        catch (error) {
+            this.error(`Failed to undo changes: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';