duoops 0.1.7 → 0.2.0

package/dist/lib/ai/agent.js

@@ -6,6 +6,49 @@ import { editingTools } from './tools/editing.js';
 import { fileTools } from './tools/filesystem.js';
 import { gitlabTools } from './tools/gitlab.js';
 import { measureTools } from './tools/measure.js';
+const baseTools = {
+    ...editingTools,
+    ...fileTools,
+    ...gitlabTools,
+    ...measureTools,
+};
+function createSystemPrompt(hasProjectId) {
+    const projectLine = hasProjectId
+        ? 'The portal already selected the GitLab project for you. All GitLab tools automatically target that project. Never attempt to guess, request, or change the project ID.'
+        : '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) {
+    return Object.fromEntries(Object.entries(baseTools).map(([name, t]) => [
+        name,
+        {
+            ...t,
+            async execute(args, options) {
+                const toolOptions = {
+                    ...(typeof options === 'object' && options !== null ? options : {}),
+                    projectId,
+                };
+                const logArgs = typeof args === 'object' && args !== null
+                    ? Object.fromEntries(Object.entries(args).filter(([key]) => key !== 'projectId' && key !== 'project_id'))
+                    : args;
+                logger.info({ args: logArgs, tool: name }, 'tool call');
+                try {
+                    const toolInstance = t;
+                    const result = await toolInstance.execute(args, toolOptions);
+                    logger.info({ result, tool: name }, 'tool result');
+                    return result;
+                }
+                catch (error) {
+                    logger.warn({ error: String(error), tool: name }, 'tool error');
+                    throw error;
+                }
+            },
+        },
+    ]));
+}
 /** Ensure no message has empty text content (Anthropic rejects "text content blocks must be non-empty"). */
 function sanitizeMessages(messages) {
     return messages.map((m) => {
@@ -38,37 +81,12 @@ function sanitizeMessages(messages) {
         return m;
     });
 }
-export const runAgent = async (input) => {
+export const runAgent = async (input, context) => {
     const model = createModel();
     const config = configManager.get();
-    const system = `You are a DevOps assistant.
-${config.defaultProjectId ? `The default GitLab Project ID is: ${config.defaultProjectId}. If the user doesn't specify a project, use this one.` : ''}
-Use the available tools to answer questions about pipelines, jobs, and sustainability.`;
-    const rawTools = {
-        ...editingTools,
-        ...fileTools,
-        ...gitlabTools,
-        ...measureTools,
-    };
-    /** Wrap each tool's execute to log invocations and results (for debugging tool round-trips). */
-    const tools = Object.fromEntries(Object.entries(rawTools).map(([name, t]) => [
-        name,
-        {
-            ...t,
-            async execute(args, options) {
-                logger.info({ args, tool: name }, 'tool call');
-                try {
-                    const result = await t.execute(args, options);
-                    logger.info({ result, tool: name }, 'tool result');
-                    return result;
-                }
-                catch (error) {
-                    logger.warn({ error: String(error), tool: name }, 'tool error');
-                    throw error;
-                }
-            },
-        },
-    ]));
+    const projectId = context?.projectId || config.defaultProjectId;
+    const system = createSystemPrompt(Boolean(projectId));
+    const tools = createTools(projectId);
     const rawMessages = Array.isArray(input)
         ? input
         : [{ content: input.trim() || ' ', role: 'user' }];
@@ -91,36 +109,12 @@ Use the available tools to answer questions about pipelines, jobs, and sustainab
     return result.text ?? '';
 };
 /** Same as runAgent but returns a streamText result for UI streaming (tool steps, etc.). */
-export function streamAgent(messages) {
+export function streamAgent(messages, context) {
     const model = createModel();
     const config = configManager.get();
-    const system = `You are a DevOps assistant.
-${config.defaultProjectId ? `The default GitLab Project ID is: ${config.defaultProjectId}. If the user doesn't specify a project, use this one.` : ''}
-Use the available tools to answer questions about pipelines, jobs, and sustainability.`;
-    const rawTools = {
-        ...editingTools,
-        ...fileTools,
-        ...gitlabTools,
-        ...measureTools,
-    };
-    const tools = Object.fromEntries(Object.entries(rawTools).map(([name, t]) => [
-        name,
-        {
-            ...t,
-            async execute(args, options) {
-                logger.info({ args, tool: name }, 'tool call');
-                try {
-                    const result = await t.execute(args, options);
-                    logger.info({ result, tool: name }, 'tool result');
-                    return result;
-                }
-                catch (error) {
-                    logger.warn({ error: String(error), tool: name }, 'tool error');
-                    throw error;
-                }
-            },
-        },
-    ]));
+    const projectId = context?.projectId || config.defaultProjectId;
+    const system = createSystemPrompt(Boolean(projectId));
+    const tools = createTools(projectId);
     const sanitized = sanitizeMessages(messages);
     if (sanitized.length === 0) {
         throw new Error('Please send a non-empty message.');

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.d.ts

@@ -1,4 +1,8 @@
 export declare const gitlabTools: {
     get_job_logs: import("ai").Tool<unknown, unknown>;
+    get_pipeline_details: import("ai").Tool<unknown, unknown>;
+    get_project: import("ai").Tool<unknown, unknown>;
+    list_jobs: import("ai").Tool<unknown, unknown>;
     list_pipelines: import("ai").Tool<unknown, unknown>;
+    search_projects: import("ai").Tool<unknown, unknown>;
 };

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

@@ -1,25 +1,44 @@
 import { generateText, tool } from 'ai';
 import { z } from 'zod';
+import { configManager } from '../../config.js';
 import { createGitlabClient } from '../../gitlab/client.js';
 import { createModel } from '../model.js';
 /* eslint-disable camelcase */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const getJobLogsSchema = z.object({
     jobId: z.number().describe('GitLab Job ID'),
-    projectId: z.string().describe('GitLab Project ID'),
 });
 const listPipelinesSchema = z.object({
     limit: z.number().default(5).optional(),
-    projectId: z.string().describe('GitLab Project ID'),
+    status: z.string().optional().describe('Filter by status (e.g. success, failed, running)'),
+});
+const getPipelineDetailsSchema = z.object({
+    pipelineId: z.number().describe('GitLab Pipeline ID'),
+});
+const listJobsSchema = z.object({
+    limit: z.number().default(20).optional(),
+    pipelineId: z.number().optional().describe('Filter by Pipeline ID'),
+    scope: z.enum(['created', 'pending', 'running', 'failed', 'success', 'canceled', 'skipped', 'manual']).optional(),
+});
+const searchProjectsSchema = z.object({
+    query: z.string().describe('Search query (project name or path)'),
+});
+const getProjectSchema = z.object({
+    projectPathOrId: z.string().optional().describe('GitLab Project Path (group/project) or ID'),
 });
 export const gitlabTools = {
     get_job_logs: tool({
         description: 'Get the logs of a specific job to debug failures. If logs are long, it uses a subagent to summarize them.',
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        async execute(args) {
+        async execute(args, options) {
             try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                const jobId = args.jobId || args.job_id;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
+                if (!jobId)
+                    throw new Error('Job ID is required');
                 const client = createGitlabClient();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const trace = await client.Jobs.showTrace(args.projectId, args.jobId);
+                const trace = await client.Jobs.showLog(projectId, jobId);
                 const logText = typeof trace === 'string' ? trace : JSON.stringify(trace);
                 // If logs are short, return directly
                 if (logText.length < 5000) {
@@ -51,15 +70,117 @@ ${content}`
             }
         },
         parameters: getJobLogsSchema,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    get_pipeline_details: tool({
+        description: 'Get detailed information about a specific pipeline, including its jobs and status.',
+        async execute(args, options) {
+            try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                const pipelineId = args.pipelineId || args.pipeline_id;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
+                if (!pipelineId)
+                    throw new Error('Pipeline ID is required');
+                const client = createGitlabClient();
+                const pipeline = await client.Pipelines.show(projectId, pipelineId);
+                const jobs = await client.Jobs.all(projectId, { pipelineId });
+                return {
+                    jobs: jobs.map((j) => ({
+                        id: j.id,
+                        name: j.name,
+                        stage: j.stage,
+                        status: j.status,
+                    })),
+                    pipeline: {
+                        created_at: pipeline.created_at,
+                        duration: pipeline.duration,
+                        id: pipeline.id,
+                        ref: pipeline.ref,
+                        status: pipeline.status,
+                        web_url: pipeline.web_url,
+                    },
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: getPipelineDetailsSchema,
+    }),
+    get_project: tool({
+        description: 'Get details of a specific project by its path (e.g. "group/project") or ID to find its numeric ID.',
+        async execute(args, options) {
+            try {
+                const projectPathOrId = options?.projectId || args.projectPathOrId || configManager.get().defaultProjectId;
+                if (!projectPathOrId)
+                    throw new Error('Project Path or ID is required (argument or default config)');
+                const client = createGitlabClient();
+                const project = await client.Projects.show(projectPathOrId);
+                return {
+                    project: {
+                        description: project.description,
+                        id: project.id,
+                        name: project.name,
+                        path_with_namespace: project.path_with_namespace,
+                        web_url: project.web_url,
+                    }
+                };
+            }
+            catch (error) {
+                return { error: `Failed to find project "${args.projectPathOrId || options?.projectId || 'unknown'}": ${String(error)}` };
+            }
+        },
+        parameters: getProjectSchema,
+    }),
+    list_jobs: tool({
+        description: 'List jobs for a project, optionally filtered by pipeline or status scope.',
+        async execute(args, options) {
+            try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                const pipelineId = args.pipelineId || args.pipeline_id;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
+                const client = createGitlabClient();
+                const queryOptions = {};
+                if (typeof args.limit === 'number') {
+                    queryOptions.perPage = args.limit;
+                }
+                if (args.scope) {
+                    queryOptions.scope = args.scope;
+                }
+                const jobs = pipelineId
+                    ? await client.Jobs.all(projectId, { ...queryOptions, pipelineId })
+                    : await client.Jobs.all(projectId, queryOptions);
+                return {
+                    jobs: jobs.map((j) => ({
+                        created_at: j.created_at,
+                        id: j.id,
+                        name: j.name,
+                        pipeline: { id: j.pipeline.id },
+                        stage: j.stage,
+                        status: j.status,
+                        web_url: j.web_url,
+                    })),
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: listJobsSchema,
     }),
     list_pipelines: tool({
         description: 'List recent pipelines for a project to check status',
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        async execute(args) {
+        async execute(args, options) {
             try {
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                if (!projectId)
+                    throw new Error('Project ID is required (argument or default config)');
                 const client = createGitlabClient();
-                const pipelines = await client.Pipelines.all(args.projectId, { perPage: args.limit });
+                const queryOptions = { perPage: args.limit };
+                if (args.status)
+                    queryOptions.status = args.status;
+                const pipelines = await client.Pipelines.all(projectId, queryOptions);
                 return {
                     pipelines: pipelines.map((p) => ({
                         created_at: p.created_at,
@@ -75,7 +196,41 @@ ${content}`
             }
         },
         parameters: listPipelinesSchema,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }),
+    search_projects: tool({
+        description: 'Search for a GitLab project by name or path to find its ID.',
+        async execute(args) {
+            try {
+                const client = createGitlabClient();
+                // search() is good for name but less precise than path.
+                // It's often useful for discovering projects.
+                // In some GitBeaker versions, this might be Projects.search(query) or Projects.all({search: query})
+                // We will try Projects.search(query) first, fallback to all({search}) if fails
+                let projects;
+                try {
+                    projects = await client.Projects.search(args.query);
+                }
+                catch {
+                    projects = await client.Projects.all({ search: args.query });
+                }
+                if (!Array.isArray(projects)) {
+                    projects = [projects];
+                }
+                return {
+                    projects: projects.map((p) => ({
+                        description: p.description,
+                        id: p.id,
+                        name: p.name,
+                        path_with_namespace: p.path_with_namespace,
+                        web_url: p.web_url,
+                    })),
+                };
+            }
+            catch (error) {
+                return { error: String(error) };
+            }
+        },
+        parameters: searchProjectsSchema,
     }),
 };
 /* eslint-enable camelcase */

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

@@ -1,18 +1,22 @@
 import { tool } from 'ai';
 import { z } from 'zod';
+import { configManager } from '../../config.js';
 import { fetchCarbonMetrics } from '../../measure/bigquery-service.js';
 /* eslint-disable camelcase */
 const getCarbonMetricsSchema = z.object({
     limit: z.number().default(10).optional(),
-    projectId: z.string().describe('GitLab Project ID (numeric)'),
 });
 export const measureTools = {
     get_carbon_metrics: tool({
         description: 'Query carbon emissions for a project from BigQuery',
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        async execute(args) {
+        async execute(args, options) {
             try {
-                const metrics = await fetchCarbonMetrics(args.projectId, args.limit);
+                const projectId = options?.projectId || configManager.get().defaultProjectId;
+                if (!projectId) {
+                    return { error: 'Project ID is required. Please select a project in the portal or configure a default project.' };
+                }
+                const metrics = await fetchCarbonMetrics(projectId, args.limit);
                 return { metrics };
             }
             catch (error) {

package/dist/lib/ai/tools/types.d.ts

@@ -0,0 +1,3 @@
+export interface ToolRuntimeContext {
+    projectId?: string;
+}

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

@@ -0,0 +1 @@
+export {};

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;

package/dist/lib/gcloud.js

@@ -0,0 +1,105 @@
+import { execSync } from 'node:child_process';
+export function requireGcloud() {
+    try {
+        execSync('gcloud --version', { stdio: 'ignore' });
+    }
+    catch {
+        throw new Error('gcloud CLI is not installed or not found in PATH. Install it from https://cloud.google.com/sdk');
+    }
+}
+export function getActiveAccount() {
+    try {
+        return execSync('gcloud config get-value account', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function detectGcpProject() {
+    try {
+        const value = execSync('gcloud config get-value project', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        return value && value !== '(unset)' ? value : undefined;
+    }
+    catch { }
+}
+export function validateProjectAccess(project) {
+    const account = getActiveAccount();
+    try {
+        execSync(`gcloud projects describe ${project} --format="value(projectId)"`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        const stderr = error.stderr || '';
+        if (stderr.includes('does not have permission') || stderr.includes('PERMISSION_DENIED')) {
+            throw new Error(`Account "${account}" does not have access to project "${project}".\n\n` +
+                `Either:\n` +
+                `  1. Switch account:        gcloud config set account <account-with-access>\n` +
+                `  2. Grant access:          Grant Owner/Editor role to ${account} on project ${project}\n` +
+                `  3. Use another project:   --gcp-project <project-id>`);
+        }
+        if (stderr.includes('not exist')) {
+            throw new Error(`GCP project "${project}" does not exist. Check the project ID.`);
+        }
+        throw new Error(`Cannot access GCP project "${project}": ${stderr.trim()}`);
+    }
+}
+export function enableApis(project, apis, log) {
+    for (const api of apis) {
+        try {
+            execSync(`gcloud services enable ${api} --project=${project} --quiet`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            log(`  ✓ ${api}`);
+        }
+        catch (error) {
+            const stderr = error.stderr || '';
+            if (stderr.includes('PERMISSION_DENIED') || stderr.includes('AUTH_PERMISSION_DENIED')) {
+                log(`  ? ${api} — no permission to enable, will attempt to proceed`);
+            }
+            else {
+                throw new Error(`Failed to enable ${api}. Enable it manually:\n` +
+                    `  https://console.developers.google.com/apis/api/${api}/overview?project=${project}\n\n` +
+                    `Then retry.`);
+            }
+        }
+    }
+}
+export function getProjectNumber(project) {
+    try {
+        return execSync(`gcloud projects describe ${project} --format="value(projectNumber)"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function ensureCloudBuildServiceAccount(project, log) {
+    const projectNumber = getProjectNumber(project);
+    if (!projectNumber) {
+        log('  ? Could not determine project number, skipping service account setup');
+        return;
+    }
+    const computeSa = `${projectNumber}-compute@developer.gserviceaccount.com`;
+    const roles = [
+        'roles/cloudbuild.builds.builder',
+        'roles/storage.admin',
+    ];
+    log(`  Granting Cloud Build permissions to ${computeSa}...`);
+    for (const role of roles) {
+        try {
+            execSync(`gcloud projects add-iam-policy-binding ${project} --member="serviceAccount:${computeSa}" --role="${role}" --quiet`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            log(`  ✓ ${role}`);
+        }
+        catch (error) {
+            const stderr = error.stderr || '';
+            if (stderr.includes('PERMISSION_DENIED')) {
+                log(`  ? ${role} — no permission to grant, will attempt deploy anyway`);
+            }
+            else {
+                log(`  ? ${role} — failed: ${stderr.trim().split('\n')[0]}`);
+            }
+        }
+    }
+}

package/dist/lib/gitlab/pipelines-service.d.ts

@@ -0,0 +1,23 @@
+export interface PortalPipeline {
+    branch: string;
+    commit_message?: string;
+    created_at: string;
+    duration_seconds?: number;
+    id: number;
+    sha: string;
+    status: string;
+    triggered_by?: string;
+    updated_at?: string;
+    web_url?: string;
+}
+export interface PortalPipelinePage {
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    page: number;
+    perPage: number;
+    pipelines: PortalPipeline[];
+}
+export declare function fetchPortalPipelines(projectId: string, options?: {
+    limit?: number;
+    page?: number;
+}): Promise<PortalPipelinePage>;