@aikidosec/ci-api-client 1.0.18 → 1.0.19

package/src/codeCoverage/sourceLineFixes.ts

@@ -0,0 +1,73 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+// Drop coverage that points past the end of the source file.
+// applied per-extension in their uploader and are not language-agnostic — we only
+export async function loadSourceLineFixes(
+  repositoryRoot: string,
+  sourcePath: string
+): Promise<{ eof: number } | null> {
+  if (!repositoryRoot || !sourcePath) {
+    return null;
+  }
+
+  try {
+    const base = path.resolve(repositoryRoot);
+    const target = path.resolve(base, sourcePath);
+    const relative = path.relative(base, target);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+      return null;
+    }
+
+    // Do not follow symlinks: a tracked link can point at an unbounded
+    // special file (e.g. /dev/zero) and hang or exhaust memory on read.
+    const stats = await fs.lstat(target);
+    if (stats.isSymbolicLink() || !stats.isFile()) {
+      return null;
+    }
+
+    const content = await fs.readFile(target, 'utf8');
+    const lineCount = content.split(/\r?\n/).length;
+    return { eof: lineCount };
+  } catch {
+    return null;
+  }
+}
+
+type TCoverageRecord = {
+  lines: Map<number, unknown>;
+  functions: Map<string, { line: number }>;
+  branches: Map<string, unknown>;
+};
+
+export function applySourceLineFixes(
+  record: TCoverageRecord,
+  lineFixes: { eof: number } | null
+): TCoverageRecord {
+  if (!lineFixes) {
+    return record;
+  }
+
+  const { eof } = lineFixes;
+
+  for (const lineNumber of record.lines.keys()) {
+    if (lineNumber < 1 || lineNumber > eof) {
+      record.lines.delete(lineNumber);
+    }
+  }
+
+  for (const [functionName, meta] of record.functions.entries()) {
+    if (meta.line < 1 || meta.line > eof) {
+      record.functions.delete(functionName);
+    }
+  }
+
+  for (const branchKey of record.branches.keys()) {
+    const lineNumber = Number(branchKey.split('\0')[0]);
+    if (lineNumber < 1 || lineNumber > eof) {
+      record.branches.delete(branchKey);
+    }
+  }
+
+  return record;
+}

package/src/commands/uploadCoverage.ts

@@ -0,0 +1,115 @@
+import { Command } from 'commander';
+import { Ora } from 'ora';
+import { uploadCodeCoverage } from '../aikidoApi.js';
+import { collectUploadPayload } from '../codeCoverage/collectUploadPayload.js';
+import { getApiKey } from '../configuration.js';
+import {
+  outputError,
+  outputHttpError,
+  outputLog,
+  startSpinner,
+} from '../output.js';
+
+type TUploadCoverageUserCliOptions = {
+  repoName: string;
+  commitSha: string;
+  branchName: string;
+  filePaths: string[];
+  repositoryId: string | number;
+};
+
+async function cli(options: TUploadCoverageUserCliOptions) {
+  const apiKey = getApiKey();
+
+  if (!apiKey) {
+    outputError('Please set an api key using: aikido-api-client apikey <key>');
+    return;
+    return;
+  }
+
+  const filePaths = normalizeFilePaths(options.filePaths);
+  if (filePaths.length === 0) {
+    outputError(
+      'No code coverage file(s) provided. Specify at least one path with --file-paths.'
+    );
+  }
+
+  let loader: Ora | null = startSpinner(
+    'Collecting coverage files and repository metadata'
+  );
+
+  let payload;
+  try {
+    payload = await collectUploadPayload(filePaths);
+  } catch (error) {
+    loader?.fail();
+    outputError(error instanceof Error ? error.message : String(error));
+    return;
+  }
+
+  loader?.succeed(
+    `Found ${payload.files.length} coverage file(s) (source paths=${payload.repository_source_paths.length}, eof=${Object.keys(payload.eof).length})`
+  );
+
+  for (const file of payload.files) {
+    outputLog(`  ${file.filename} (${file.format})`);
+  }
+
+  loader = startSpinner('Uploading code coverage to Aikido');
+
+  try {
+    await uploadCodeCoverage({
+      repository_id: options.repositoryId,
+      repo_name: options.repoName,
+      commit_sha: options.commitSha,
+      branch_name: options.branchName,
+      repository_source_paths: payload.repository_source_paths,
+      eof: payload.eof,
+      files: payload.files,
+    });
+
+    
+    loader?.succeed('Code coverage upload completed');
+    process.exit(0);
+  } catch (error) {
+    loader?.fail();
+    outputHttpError(error as any);
+    process.exit(1);
+  }
+}
+
+const normalizeFilePaths = (filePaths: string[]): string[] =>
+  filePaths
+    .flatMap((entry) => entry.split(/\n|\s+|,/))
+    .map((filePath) => filePath.trim())
+    .filter(Boolean);
+
+export const cliSetup = (program: Command) =>
+  program
+    .command('upload-coverage')
+    .requiredOption(
+      '-r, --repo-name <reponame>',
+      'Repository name as owner/repo (e.g. org/my-repo)'
+    )
+    .requiredOption(
+      '-c, --commit-sha <commitsha>',
+      'The commit SHA for this CI run'
+    )
+    .requiredOption(
+      '-b, --branch-name <branchname>',
+      'The branch name for this CI run'
+    )
+    .requiredOption(
+      '-f, --file-paths <paths...>',
+      'Path(s) to LCOV or Cobertura coverage report(s). Format is detected from each filename.'
+    )
+    .requiredOption(
+      '-ri, --repository-id <repositoryid>',
+      'The scm repository id'
+    )
+    .description(
+      'Upload LCOV or Cobertura coverage reports to Aikido (with repository_source_paths and EOF metadata).'
+    )
+    .action(cli);
+
+export default { cli, cliSetup };

package/src/index.ts

@@ -6,6 +6,7 @@ import apiKey from './commands/apiKey.js';
 import scan from './commands/scan.js';
 import scanRelease from './commands/scanRelease.js';
 import upload from './commands/upload.js';
+import uploadCoverage from './commands/uploadCoverage.js';
 
 // Load all .env configuration variables and auto-inject them into process.env
 dotenv.config(
@@ -27,6 +28,7 @@ apiKey.cliSetup(program);
 scan.cliSetup(program);
 scanRelease.cliSetup(program);
 upload.cliSetup(program);
+uploadCoverage.cliSetup(program);
 
 // Override global process.env type
 declare global {