duoops 0.1.9 → 0.2.1

package/dist/commands/measure/calculate.js

@@ -80,13 +80,13 @@ export default class CarbonCalculate extends Command {
         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
+        // In production (dist), __dirname is .../dist/commands/measure
         // 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');
+        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');

package/dist/commands/portal.js

@@ -6,15 +6,19 @@ 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 { runAgent, streamAgent } from '../lib/ai/agent.js';
 import { configManager } from '../lib/config.js';
+import { getPipelineProvider } from '../lib/gitlab/index.js';
+import { fetchPortalPipelines } from '../lib/gitlab/pipelines-service.js';
+import { fetchProjectRunners } from '../lib/gitlab/runner-service.js';
 import { fetchAvailableProjects, fetchCarbonMetrics } from '../lib/measure/bigquery-service.js';
+import { getPortalBudgets, savePortalBudgets } from '../lib/portal/settings.js';
 export default class Portal extends Command {
     static description = 'Launch the DuoOps web portal';
     static flags = {
         port: Flags.integer({
             char: 'p',
-            default: 3000,
+            default: 58_327,
             description: 'Port to run the portal on',
         }),
     };
@@ -73,8 +77,9 @@ export default class Portal extends Command {
                     res.json([]);
                     return;
                 }
-                this.error(String(error), { exit: false });
-                res.status(500).json({ error: String(error) });
+                // Log error but return empty array so frontend doesn't break if BQ is down/misconfigured
+                this.warn(`Failed to fetch projects: ${error}`);
+                res.json([]);
             }
         });
         app.get('/api/metrics', async (req, res) => {
@@ -108,6 +113,183 @@ export default class Portal extends Command {
                 bigqueryActive,
             });
         });
+        app.get('/api/pipelines', async (req, res) => {
+            try {
+                const config = configManager.get();
+                const queryProjectId = Array.isArray(req.query.projectId) ? req.query.projectId[0] : req.query.projectId;
+                const queryLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
+                const queryPage = Array.isArray(req.query.page) ? req.query.page[0] : req.query.page;
+                const targetProjectId = queryProjectId
+                    ? String(queryProjectId)
+                    : config.defaultProjectId;
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                const parsedLimit = queryLimit ? Number(queryLimit) : undefined;
+                const parsedPage = queryPage ? Number(queryPage) : undefined;
+                const result = await fetchPortalPipelines(targetProjectId, {
+                    limit: Number.isFinite(parsedLimit) && parsedLimit !== undefined
+                        ? parsedLimit
+                        : undefined,
+                    page: Number.isFinite(parsedPage) && parsedPage !== undefined
+                        ? parsedPage
+                        : undefined,
+                });
+                res.json({
+                    pagination: {
+                        hasNextPage: result.hasNextPage,
+                        hasPrevPage: result.hasPrevPage,
+                        page: result.page,
+                        perPage: result.perPage,
+                    },
+                    pipelines: result.pipelines,
+                    projectId: targetProjectId,
+                });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/dashboard', async (req, res) => {
+            try {
+                const config = configManager.get();
+                const queryProjectId = Array.isArray(req.query.projectId) ? req.query.projectId[0] : req.query.projectId;
+                const targetProjectId = queryProjectId
+                    ? String(queryProjectId)
+                    : config.defaultProjectId;
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                let metrics = [];
+                try {
+                    metrics = await fetchCarbonMetrics(targetProjectId, 200);
+                }
+                catch (metricError) {
+                    if (!String(metricError).includes('not configured')) {
+                        this.warn(`Failed to load metrics for dashboard: ${metricError}`);
+                    }
+                    metrics = [];
+                }
+                const summary = buildDashboardSummary(metrics);
+                const budgetSettings = getPortalBudgets();
+                const budgets = buildBudgetStatuses(summary, budgetSettings);
+                const alerts = buildAlerts(budgets);
+                let runnerHealth = [];
+                try {
+                    runnerHealth = await fetchProjectRunners(targetProjectId);
+                }
+                catch (runnerError) {
+                    this.warn(`Failed to fetch runner health: ${runnerError}`);
+                    runnerHealth = [];
+                }
+                const recommendations = await buildRecommendations({
+                    metrics,
+                    onError: (recommendationError) => {
+                        this.warn(`Failed to generate dashboard recommendations: ${recommendationError}`);
+                    },
+                    projectId: targetProjectId,
+                    summary,
+                });
+                res.json({
+                    alerts,
+                    budgets,
+                    budgetSettings,
+                    metricsPreview: metrics.slice(0, 10),
+                    projectId: targetProjectId,
+                    recommendations,
+                    runnerHealth,
+                    summary,
+                });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/budgets', (req, res) => {
+            try {
+                const budgets = getPortalBudgets();
+                res.json({ budgets });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.put('/api/budgets', (req, res) => {
+            try {
+                const { budgets } = req.body;
+                if (!Array.isArray(budgets) || budgets.length === 0) {
+                    res.status(400).json({ error: 'Budgets array is required' });
+                    return;
+                }
+                const sanitized = budgets
+                    .map((budget) => ({
+                    id: String(budget.id ?? ''),
+                    limit: Number(budget.limit),
+                    name: String(budget.name ?? ''),
+                    period: String(budget.period ?? ''),
+                    unit: String(budget.unit ?? ''),
+                }))
+                    .filter((budget) => budget.id && budget.name && budget.unit && Number.isFinite(budget.limit) && budget.limit > 0);
+                if (sanitized.length === 0) {
+                    res.status(400).json({ error: 'No valid budgets provided' });
+                    return;
+                }
+                savePortalBudgets(sanitized);
+                res.json({ budgets: getPortalBudgets() });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.get('/api/runners', async (req, res) => {
+            try {
+                const targetProjectId = resolveProjectId(req);
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                const runners = await fetchProjectRunners(targetProjectId);
+                res.json({ projectId: targetProjectId, runners });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
+        app.post('/api/autofix', async (req, res) => {
+            try {
+                const targetProjectId = resolveProjectId(req);
+                if (!targetProjectId) {
+                    res.status(400).json({ error: 'Project ID is required and no default is configured' });
+                    return;
+                }
+                const provider = getPipelineProvider();
+                const latest = await fetchLatestFailedPipeline(provider, targetProjectId);
+                if (!latest) {
+                    res.status(404).json({ error: 'No failing pipelines found to inspect.' });
+                    return;
+                }
+                const jobs = await provider.listJobs(targetProjectId, latest.id);
+                const prompt = buildAutofixPrompt(latest, jobs);
+                const analysis = await runAgent(prompt, { projectId: targetProjectId });
+                res.json({
+                    analysis,
+                    jobs,
+                    pipeline: latest,
+                    projectId: targetProjectId,
+                });
+            }
+            catch (error) {
+                this.error(String(error), { exit: false });
+                res.status(500).json({ error: String(error) });
+            }
+        });
         // Serve Static Files (Frontend)
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         // Try resolving relative to the compiled command file (dist/commands/portal.js)
@@ -134,8 +316,241 @@ export default class Portal extends Command {
         });
         app.listen(port, async () => {
             const url = `http://localhost:${port}`;
-            this.log(`🚀 DuoOps Portal running at ${url}`);
-            await open(url);
+            const query = new URLSearchParams();
+            const defaultTab = process.env.DUOOPS_PORTAL_DEFAULT_TAB;
+            const presetMessage = process.env.DUOOPS_PORTAL_PRESET_MESSAGE;
+            if (defaultTab) {
+                query.set('tab', defaultTab);
+            }
+            if (presetMessage) {
+                query.set('preset', presetMessage);
+            }
+            const finalUrl = query.size > 0 ? `${url}?${query.toString()}` : url;
+            this.log(`🚀 DuoOps Portal running at ${finalUrl}`);
+            await open(finalUrl);
         });
     }
 }
+function buildDashboardSummary(metrics) {
+    if (!metrics || metrics.length === 0) {
+        return {
+            avgEmissions: 0,
+            avgRuntime: 0,
+            jobCount: 0,
+            totalEmissions: 0,
+            totalEnergy: 0,
+        };
+    }
+    let totalEmissions = 0;
+    let totalEnergy = 0;
+    let totalRuntime = 0;
+    let lastIngestedAt;
+    for (const metric of metrics) {
+        totalEmissions += Number(metric.total_emissions_g ?? 0);
+        totalEnergy += Number(metric.energy_kwh ?? 0);
+        totalRuntime += Number(metric.runtime_seconds ?? 0);
+        const ingested = typeof metric.ingested_at === 'object' && metric.ingested_at !== null
+            ? String(metric.ingested_at.value ?? '')
+            : undefined;
+        if (ingested && (!lastIngestedAt || ingested > lastIngestedAt)) {
+            lastIngestedAt = ingested;
+        }
+    }
+    const jobCount = metrics.length;
+    const avgEmissions = jobCount === 0 ? 0 : totalEmissions / jobCount;
+    const avgRuntime = jobCount === 0 ? 0 : totalRuntime / jobCount;
+    return {
+        avgEmissions,
+        avgRuntime,
+        jobCount,
+        lastIngestedAt,
+        totalEmissions,
+        totalEnergy,
+    };
+}
+function buildBudgetStatuses(summary, configs) {
+    return configs.map((config) => {
+        const used = getBudgetUsage(config.id, summary);
+        const status = computeBudgetStatus(used, config.limit);
+        const percent = config.limit === 0 ? 0 : (used / config.limit) * 100;
+        return {
+            id: config.id,
+            limit: config.limit,
+            name: config.name,
+            percent,
+            period: config.period,
+            status,
+            unit: config.unit,
+            used,
+        };
+    });
+}
+function computeBudgetStatus(used, limit) {
+    if (limit === 0)
+        return 'ok';
+    const ratio = used / limit;
+    if (ratio >= 1)
+        return 'breached';
+    if (ratio >= 0.85)
+        return 'warning';
+    return 'ok';
+}
+function getBudgetUsage(budgetId, summary) {
+    switch (budgetId) {
+        case 'runtime': {
+            return summary.avgRuntime * summary.jobCount;
+        }
+        default: {
+            return summary.totalEmissions;
+        }
+    }
+}
+function buildAlerts(budgets) {
+    return budgets
+        .filter((budget) => budget.status !== 'ok')
+        .map((budget) => ({
+        id: `${budget.id}-alert`,
+        message: budget.status === 'breached'
+            ? `${budget.name} exceeded by ${(budget.used - budget.limit).toFixed(1)} ${budget.unit}.`
+            : `${budget.name} is at ${budget.percent.toFixed(0)}% of limit.`,
+        relatedBudgetId: budget.id,
+        severity: budget.status === 'breached' ? 'critical' : 'warning',
+    }));
+}
+async function buildRecommendations(options) {
+    const { metrics, onError, projectId, summary } = options;
+    const topJobs = metrics
+        .filter((m) => typeof m.total_emissions_g === 'number')
+        .sort((a, b) => Number(b.total_emissions_g ?? 0) - Number(a.total_emissions_g ?? 0))
+        .slice(0, 5)
+        .map((job) => ({
+        emissions: Number(job.total_emissions_g ?? 0),
+        jobId: job.gitlab_job_id,
+        machineType: job.machine_type,
+        runtime: job.runtime_seconds,
+    }));
+    const prompt = `You are advising on sustainable CI pipelines. Given this summary JSON:\n${JSON.stringify({
+        summary,
+        topJobs,
+    })}\nSuggest three concrete optimization ideas. Respond with a JSON array of objects like {"title": "...", "description": "..."}`;
+    try {
+        const response = await runAgent(prompt, { projectId });
+        const parsed = parseRecommendations(response);
+        if (parsed.length > 0) {
+            return parsed.map((item, index) => ({
+                description: item.description,
+                id: `agent-${index}`,
+                source: 'agent',
+                title: item.title,
+            }));
+        }
+    }
+    catch (error) {
+        onError?.(error);
+    }
+    return buildHeuristicRecommendations(summary, metrics);
+}
+function parseRecommendations(text) {
+    try {
+        const data = JSON.parse(text);
+        if (Array.isArray(data)) {
+            return data
+                .map((entry) => ({
+                description: typeof entry.description === 'string' ? entry.description : '',
+                title: typeof entry.title === 'string' ? entry.title : '',
+            }))
+                .filter((entry) => entry.title);
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
+function buildHeuristicRecommendations(summary, metrics) {
+    const recommendations = [];
+    if (summary.totalEmissions > 0) {
+        recommendations.push({
+            description: 'Cache dependencies and artifacts across pipelines to avoid repeating high-emission stages on every run.',
+            id: 'heuristic-cache',
+            source: 'heuristic',
+            title: 'Reduce redundant work',
+        });
+    }
+    const longestJob = metrics
+        .filter((m) => typeof m.runtime_seconds === 'number')
+        .sort((a, b) => Number(b.runtime_seconds ?? 0) - Number(a.runtime_seconds ?? 0))[0];
+    if (longestJob &&
+        typeof longestJob.runtime_seconds === 'number' &&
+        summary.avgRuntime > 0 &&
+        Number(longestJob.runtime_seconds) > summary.avgRuntime * 1.25) {
+        recommendations.push({
+            description: `Job ${longestJob.gitlab_job_id ?? ''} is much slower than average—consider splitting it into parallel stages or running it on a larger runner.`,
+            id: 'heuristic-longest',
+            source: 'heuristic',
+            title: 'Investigate the slowest job',
+        });
+    }
+    if (summary.totalEnergy > 0 && summary.totalEmissions / (summary.totalEnergy * 1000) > 0.8) {
+        recommendations.push({
+            description: 'Energy intensity is trending high. Shift long-running stages to greener regions or off-peak windows.',
+            id: 'heuristic-intensity',
+            source: 'heuristic',
+            title: 'Schedule jobs for greener power',
+        });
+    }
+    if (recommendations.length === 0) {
+        recommendations.push({
+            description: 'Track a carbon budget per pipeline and alert when emissions spike after merges.',
+            id: 'heuristic-default',
+            source: 'heuristic',
+            title: 'Establish sustainability guardrails',
+        });
+    }
+    return recommendations.slice(0, 3);
+}
+function resolveProjectId(req) {
+    const config = configManager.get();
+    const queryProjectId = Array.isArray(req.query.projectId) ? req.query.projectId[0] : req.query.projectId;
+    const bodyProjectId = typeof req.body === 'object' && req.body !== null && 'projectId' in req.body
+        ? String(req.body.projectId ?? '')
+        : undefined;
+    const targetProjectId = bodyProjectId && bodyProjectId.trim().length > 0
+        ? bodyProjectId
+        : queryProjectId
+            ? String(queryProjectId)
+            : config.defaultProjectId;
+    return targetProjectId ?? null;
+}
+async function fetchLatestFailedPipeline(provider, projectId) {
+    const pipelines = await provider.listPipelines(projectId, { perPage: 10, status: 'failed' });
+    const failed = pipelines.find((pipeline) => pipeline.status === 'failed');
+    return failed ?? null;
+}
+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.
+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. Identify the most likely cause of the failure based on the jobs above.
+2. Propose concrete remediation steps, referencing jobs and stages explicitly.
+3. Suggest any GitLab CI configuration changes or code adjustments to prevent this regression.
+4. Outline validation steps once the fix is applied.
+
+Respond in Markdown with clear sections: Root Cause, Fix Plan, Validation.`;
+}

package/dist/lib/ai/agent.js

@@ -18,6 +18,7 @@ function createSystemPrompt(hasProjectId) {
         : 'If a GitLab project has not been configured yet, ask the user to select one before running GitLab tools.';
     return `You are a DevOps assistant.
 ${projectLine}
+Before changing CI configs or runner scripts, inspect the DuoOps CLI source (e.g. src/commands/measure/*) and confirm whether the tool already bundles required data under the package's data/ directory; avoid inventing placeholder directories or files when the CLI provides them.
 Use the available tools to answer questions about pipelines, jobs, and sustainability.`;
 }
 function createTools(projectId) {

package/dist/lib/ai/tools/editing.js

@@ -8,34 +8,49 @@ import { z } from 'zod';
 import { ensureDuoOpsDir, PATCHES_DIR } from '../../state.js';
 const execAsync = promisify(exec);
 /* eslint-disable camelcase */
-const patchFileSchema = z.object({
-    filePath: z.string().describe('Relative path to the file to edit'),
-    newString: z.string().describe('The new content to replace with'),
-    oldString: z.string().describe('The exact existing content to search for and replace'),
+const patchFileSchema = z
+    .object({
+    filePath: z.string().describe('Relative path to the file to edit').optional(),
+    newString: z.string().describe('The new content to replace with').optional(),
+    oldString: z.string().describe('The exact existing content to search for and replace').optional(),
+    original_content: z.string().describe('Alias for oldString used by some agents').optional(),
+    patched_content: z.string().describe('Alias for newString used by some agents').optional(),
+    path: z.string().describe('Alias for filePath used by some agents').optional(),
+})
+    .refine((args) => Boolean((args.filePath ?? args.path) &&
+    (args.oldString ?? args.original_content) &&
+    (args.newString ?? args.patched_content)), {
+    message: 'filePath/path, oldString/original_content, and newString/patched_content are required',
 });
 export const editingTools = {
     patch_file: tool({
         description: 'Safely edit a file by creating and applying a reversible patch',
         async execute(args) {
             try {
-                const fullPath = path.resolve(process.cwd(), args.filePath);
+                const filePath = args.filePath ?? args.path;
+                const oldString = args.oldString ?? args.original_content;
+                const newString = args.newString ?? args.patched_content;
+                if (!filePath || !oldString || !newString) {
+                    return { error: 'filePath/path, oldString/original_content, and newString/patched_content are required' };
+                }
+                const fullPath = path.resolve(process.cwd(), filePath);
                 if (!fs.existsSync(fullPath)) {
-                    return { error: `File not found: ${args.filePath}` };
+                    return { error: `File not found: ${filePath}` };
                 }
                 const content = fs.readFileSync(fullPath, 'utf8');
                 // Safety check: Ensure oldString exists exactly once to avoid ambiguity
                 // Or at least exists.
-                if (!content.includes(args.oldString)) {
-                    return { error: `Could not find exact match for oldString in ${args.filePath}. Please read the file again to ensure accuracy.` };
+                if (!content.includes(oldString)) {
+                    return { error: `Could not find exact match for oldString in ${filePath}. Please read the file again to ensure accuracy.` };
                 }
-                const newContent = content.replaceAll(args.oldString, args.newString);
+                const newContent = content.replaceAll(oldString, newString);
                 // Generate Unified Diff
                 // createPatch(fileName, oldStr, newStr, oldHeader, newHeader)
-                const patchContent = createPatch(args.filePath, content, newContent);
+                const patchContent = createPatch(filePath, content, newContent);
                 // Save patch
                 ensureDuoOpsDir();
                 const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
-                const patchName = `${path.basename(args.filePath)}-${timestamp}.patch`;
+                const patchName = `${path.basename(filePath)}-${timestamp}.patch`;
                 const patchPath = path.join(PATCHES_DIR, patchName);
                 fs.writeFileSync(patchPath, patchContent);
                 // Apply patch using git apply
@@ -43,7 +58,7 @@ export const editingTools = {
                 // --ignore-space-change might be useful, but let's be strict first
                 await execAsync(`git apply "${patchPath}"`);
                 return {
-                    message: `Successfully applied patch to ${args.filePath}`,
+                    message: `Successfully applied patch to ${filePath}`,
                     patchPath,
                     status: 'success',
                 };
@@ -58,4 +73,4 @@ export const editingTools = {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     }),
 };
-/* eslint-enable camelcase */ 
+/* eslint-enable camelcase */

package/dist/lib/ai/tools/gitlab.js

@@ -83,7 +83,7 @@ ${content}`
                     throw new Error('Pipeline ID is required');
                 const client = createGitlabClient();
                 const pipeline = await client.Pipelines.show(projectId, pipelineId);
-                const jobs = await client.Pipelines.showJobs(projectId, pipelineId);
+                const jobs = await client.Jobs.all(projectId, { pipelineId });
                 return {
                     jobs: jobs.map((j) => ({
                         id: j.id,
@@ -141,11 +141,15 @@ ${content}`
                 if (!projectId)
                     throw new Error('Project ID is required (argument or default config)');
                 const client = createGitlabClient();
-                const queryOptions = { perPage: args.limit };
-                if (args.scope)
+                const queryOptions = {};
+                if (typeof args.limit === 'number') {
+                    queryOptions.perPage = args.limit;
+                }
+                if (args.scope) {
                     queryOptions.scope = args.scope;
+                }
                 const jobs = pipelineId
-                    ? await client.Pipelines.showJobs(projectId, pipelineId, queryOptions)
+                    ? await client.Jobs.all(projectId, { ...queryOptions, pipelineId })
                     : await client.Jobs.all(projectId, queryOptions);
                 return {
                     jobs: jobs.map((j) => ({

package/dist/lib/config.d.ts

@@ -8,6 +8,9 @@ export interface DuoOpsConfig {
         bigqueryTable?: string;
         googleProjectId?: string;
     };
+    portal?: {
+        budgets?: PortalBudgetConfig[];
+    };
     runner?: {
         gcpInstanceId?: string;
         gcpProjectId?: string;
@@ -16,6 +19,13 @@ export interface DuoOpsConfig {
         machineType?: string;
     };
 }
+export interface PortalBudgetConfig {
+    id: string;
+    limit: number;
+    name: string;
+    period: string;
+    unit: string;
+}
 export declare class ConfigManager {
     private configPath;
     constructor();

package/dist/lib/gcloud.d.ts

@@ -0,0 +1,7 @@
+export declare function requireGcloud(): void;
+export declare function getActiveAccount(): string;
+export declare function detectGcpProject(): string | undefined;
+export declare function validateProjectAccess(project: string): void;
+export declare function enableApis(project: string, apis: string[], log: (msg: string) => void): void;
+export declare function getProjectNumber(project: string): string | undefined;
+export declare function ensureCloudBuildServiceAccount(project: string, log: (msg: string) => void): void;