@aikidosec/ci-api-client 1.0.18 → 1.0.20

package/src/codeCoverage/reportPaths.ts

@@ -0,0 +1,63 @@
+import { normalizePathSeparators, normalizeSourcePath } from './paths.js';
+
+export type TCoverageFormat = 'lcov' | 'cobertura';
+
+/**
+ * Detect coverage format from the report filename only.
+ */
+export function detectFormatFromFilename(filename: string): TCoverageFormat {
+  const lower = normalizePathSeparators(filename).toLowerCase();
+  const base = lower.slice(lower.lastIndexOf('/') + 1);
+
+  if (base.endsWith('.lcov') || base.endsWith('.info') || base.includes('lcov')) {
+    return 'lcov';
+  }
+
+  if (base.endsWith('.xml') || base.includes('cobertura')) {
+    return 'cobertura';
+  }
+
+  throw new Error(
+    `Could not detect coverage format from filename "${filename}". ` +
+      'Use a name like lcov.info, *.lcov, or *cobertura*.xml.'
+  );
+}
+
+/**
+ * Extract source file paths referenced in a coverage report (for EOF map).
+ */
+export function extractCoveredSourcePaths(
+  content: string,
+  format: TCoverageFormat,
+  repositoryRoot: string
+): string[] {
+  if (format === 'cobertura') {
+    return extractCoberturaFilenames(content, repositoryRoot);
+  }
+
+  return extractLcovFilenames(content, repositoryRoot);
+}
+
+function extractLcovFilenames(
+  content: string,
+  repositoryRoot: string
+): string[] {
+  return [...content.matchAll(/^SF:([^\r\n]+)$/gm)]
+    .map((match) => normalizeSourcePath(match[1], repositoryRoot))
+    .filter(Boolean);
+}
+
+function extractCoberturaFilenames(
+  content: string,
+  repositoryRoot: string
+): string[] {
+  const paths: string[] = [];
+  for (const match of content.matchAll(/\bfilename\s*=\s*"([^"]+)"/gi)) {
+    const normalized = normalizeSourcePath(match[1], repositoryRoot);
+    if (normalized) {
+      paths.push(normalized);
+    }
+  }
+
+  return paths;
+}

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/scan.ts

@@ -245,7 +245,7 @@ export const scan = async ({
 const parseCliOptions = (userCliOptions: TScanUserCliOptions) => {
   // Version provided to the API corresponds with the version in package.json
   // of the cli client
-  const apiOptions: TScanApiOptions = { version: '1.0.18' };
+  const apiOptions: TScanApiOptions = { version: '1.0.20' };
   const cliOptions: TScanCliOptions = { pollInterval: 5 };
 
   if (userCliOptions.pullRequestTitle) {

package/src/commands/scanRelease.ts

@@ -269,7 +269,7 @@ export const scan = async ({
 const parseCliOptions = (userCliOptions: TScanUserCliOptions) => {
   // Version provided to the API corresponds with the version in package.json
   // of the cli client
-  const apiOptions: TScanApiOptions = { version: '1.0.18' };
+  const apiOptions: TScanApiOptions = { version: '1.0.20' };
   const cliOptions: TScanCliOptions = { pollInterval: 10, json: false };
 
   if (userCliOptions.pullRequestTitle) {

package/src/commands/uploadCoverage.ts

@@ -0,0 +1,108 @@
+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 = {
+  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;
+  }
+
+  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,
+      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(
+      '-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(
@@ -20,13 +21,14 @@ program
   .description(
     'CLI api client to easily integrate the Aikido public CI API into custom deploy scripts'
   )
-  .version('1.0.18');
+  .version('1.0.20');
 
 // Load in all app commands and set them up in the `program` instance
 apiKey.cliSetup(program);
 scan.cliSetup(program);
 scanRelease.cliSetup(program);
 upload.cliSetup(program);
+uploadCoverage.cliSetup(program);
 
 // Override global process.env type
 declare global {