codeant-cli 0.4.6 → 0.4.8

package/src/commands/scans/start-scan.js

@@ -0,0 +1,90 @@
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+import { detectRepoName } from '../../scm/index.js';
+import { startScan } from '../../scans/startScan.js';
+
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+
+// Mirrors splitGlobs in src/index.js (not exported) — preserves commas inside {} brace expansions
+function splitGlobs(input) {
+  const parts = [];
+  let current = '';
+  let depth = 0;
+  for (const ch of String(input)) {
+    if (ch === '{') depth++;
+    else if (ch === '}') depth--;
+    if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts.filter(Boolean);
+}
+
+async function resolveCurrentBranch() {
+  try {
+    const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD');
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+async function resolveRemoteCommit(branch) {
+  try {
+    const { stdout } = await execFileAsync('git', ['ls-remote', 'origin', `refs/heads/${branch}`]);
+    const sha = stdout.trim().split(/\s+/)[0];
+    if (!sha) {
+      const err = new Error(`Branch "${branch}" not found on remote origin. Pass --commit <sha> explicitly.`);
+      err.exitCode = 1;
+      throw err;
+    }
+    return sha;
+  } catch (err) {
+    if (err.exitCode) throw err;
+    const wrapped = new Error(`Could not resolve commit for branch "${branch}": ${err.message}. Pass --commit <sha> explicitly.`);
+    wrapped.exitCode = 1;
+    throw wrapped;
+  }
+}
+
+export async function runStartScan({ repo, branch, commit, include, exclude } = {}) {
+  const resolvedRepo = repo || detectRepoName();
+  if (!resolvedRepo) {
+    const err = new Error('Could not detect repo name. Use --repo owner/repo');
+    err.exitCode = 1;
+    throw err;
+  }
+
+  const resolvedBranch = branch || await resolveCurrentBranch();
+  if (!resolvedBranch) {
+    const err = new Error('Could not detect current branch. Use --branch <name>');
+    err.exitCode = 1;
+    throw err;
+  }
+
+  const commitId = commit || await resolveRemoteCommit(resolvedBranch);
+
+  const includeFiles = include ? splitGlobs(include) : [];
+  const excludeFiles = exclude ? splitGlobs(exclude) : [];
+
+  const result = await startScan({
+    repo: resolvedRepo,
+    branch: resolvedBranch,
+    commitId,
+    includeFiles: includeFiles.length ? includeFiles : undefined,
+    excludeFiles: excludeFiles.length ? excludeFiles : undefined,
+  });
+
+  if (!result.success) {
+    const err = new Error(result.error || 'Failed to start scan');
+    err.exitCode = 1;
+    throw err;
+  }
+
+  console.log(result.message || 'Analysis started');
+}

package/src/components/ScanCenter.js

@@ -0,0 +1,337 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import SelectList from './SelectList.js';
+import { validateConnectionOnMount } from '../scanCenter/validateConnectionOnMount.js';
+import { handleSelectConnection as _handleSelectConnection } from '../scanCenter/handleSelectConnection.js';
+import { handleSelectRepo as _handleSelectRepo } from '../scanCenter/handleSelectRepo.js';
+import { handleSelectScan as _handleSelectScan } from '../scanCenter/handleSelectScan.js';
+import { handleSelectResultType as _handleSelectResultType } from '../scanCenter/handleSelectResultType.js';
+
+const ce = React.createElement;
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const STEPS = {
+  LOADING: 'loading',
+  SELECT_CONNECTION: 'select-connection',
+  SELECT_REPO: 'select-repo',
+  SELECT_SCAN: 'select-scan',
+  SELECT_RESULT_TYPE: 'select-result-type',
+  SHOWING_RESULTS: 'showing-results',
+  ERROR: 'error',
+};
+
+const RESULT_TYPES = [
+  { label: 'Security Issues (SAST)',  value: 'security_issues',   kind: 'basic' },
+  { label: 'Anti-Patterns',           value: 'anti_patterns',     kind: 'basic' },
+  { label: 'Docstring Issues',        value: 'docstring',         kind: 'basic' },
+  { label: 'Complex Functions',       value: 'complex_functions', kind: 'basic' },
+  { label: 'SCA — Dependencies',      value: 'sca',               kind: 'advanced' },
+  { label: 'SBOM',                    value: 'sbom',              kind: 'advanced' },
+  { label: 'Secrets',                 value: 'secrets',           kind: 'advanced' },
+  { label: 'IaC (Infrastructure)',    value: 'iac',               kind: 'advanced' },
+  { label: 'Dead Code',               value: 'dead_code',         kind: 'advanced' },
+  { label: 'Dismissed Alerts',        value: 'dismissed_alerts',  kind: 'dismissed' },
+  { label: 'Dismissed Secrets',       value: 'dismissed_secrets', kind: 'dismissed' },
+];
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const RESULTS_PAGE = 15;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function severityColor(sev) {
+  if (!sev) return 'gray';
+  const s = sev.toLowerCase();
+  if (s === 'critical' || s === 'high') return 'red';
+  if (s === 'medium' || s === 'warning') return 'yellow';
+  if (s === 'low') return 'cyan';
+  return 'gray';
+}
+
+function severityLabel(sev) {
+  if (!sev) return 'INFO';
+  return sev.toUpperCase().slice(0, 4);
+}
+
+// ─── Spinner ─────────────────────────────────────────────────────────────────
+
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 100);
+    return () => clearInterval(id);
+  }, []);
+  return ce(
+    Box,
+    null,
+    ce(Text, { color: 'cyan' }, SPINNER_FRAMES[frame] + ' '),
+    ce(Text, null, label)
+  );
+}
+
+// ─── Breadcrumb ──────────────────────────────────────────────────────────────
+
+function Breadcrumb({ parts }) {
+  return ce(
+    Box,
+    { marginBottom: 1 },
+    ...parts.map((p, i) =>
+      ce(Text, { key: i, color: i === parts.length - 1 ? 'cyan' : 'gray' },
+        (i > 0 ? ' › ' : '') + p)
+    )
+  );
+}
+
+// ─── Results view ────────────────────────────────────────────────────────────
+
+function ResultsView({ issues, resultTypeLabel, breadcrumbParts, onBack }) {
+  const [offset, setOffset] = useState(0);
+
+  useInput((input, key) => {
+    if (input === 'b' || key.escape) { onBack(); return; }
+    if (key.downArrow) setOffset((o) => Math.min(o + 1, Math.max(0, issues.length - RESULTS_PAGE)));
+    if (key.upArrow)   setOffset((o) => Math.max(0, o - 1));
+  });
+
+  const visible = issues.slice(offset, offset + RESULTS_PAGE);
+
+  const rows = issues.length === 0
+    ? [ce(Box, { key: 'empty', marginBottom: 1 }, ce(Text, { color: 'green' }, '✓ No issues found'))]
+    : [
+        ce(Box, { key: 'counter', marginBottom: 1 },
+          ce(Text, { color: 'gray' },
+            `Showing ${offset + 1}–${Math.min(offset + RESULTS_PAGE, issues.length)} of ${issues.length} issues`)
+        ),
+        ...visible.map((issue, i) =>
+          ce(
+            Box,
+            { key: i, flexDirection: 'row', gap: 1 },
+            ce(Text, { color: severityColor(issue.severity), bold: true },
+              `[${severityLabel(issue.severity)}]`),
+            ce(Text, { color: 'gray' },
+              (issue.file_path || 'unknown') + (issue.line_number ? `:${issue.line_number}` : '')),
+            ce(Text, null,
+              issue.check_name || issue.issue_text || issue.message || issue.test_id || issue.type || issue.reason_for_dismiss || 'Dismissed finding')
+          )
+        ),
+      ];
+
+  return ce(
+    Box,
+    { flexDirection: 'column', paddingX: 1 },
+    ce(Breadcrumb, { parts: [...breadcrumbParts, resultTypeLabel] }),
+    ...rows,
+    ce(
+      Box,
+      { marginTop: 1, borderStyle: 'single', borderColor: 'gray', paddingX: 1 },
+      ce(Text, { color: 'gray' }, '[↑↓] scroll   [b] back')
+    )
+  );
+}
+
+// ─── Error view ──────────────────────────────────────────────────────────────
+
+function ErrorView({ message, onBack, canGoBack }) {
+  useInput((input, key) => {
+    if (input === 'b' || key.escape || key.return) onBack();
+  });
+  return ce(
+    Box,
+    { flexDirection: 'column', paddingX: 1, paddingY: 1 },
+    ce(Text, { color: 'red', bold: true }, '✖ Error'),
+    ce(Box, { marginTop: 1 },
+      ce(Text, null, message)
+    ),
+    ce(
+      Box,
+      { marginTop: 1, borderStyle: 'single', borderColor: 'gray', paddingX: 1 },
+      ce(Text, { color: 'gray' }, canGoBack ? '[b / Enter] go back' : '[b / Enter] exit')
+    )
+  );
+}
+
+// ─── Main ScanCenter ─────────────────────────────────────────────────────────
+
+export default function ScanCenter() {
+  const { exit } = useApp();
+
+  const [step, setStep] = useState(STEPS.LOADING);
+  const [loadingMsg, setLoadingMsg] = useState('Validating connection…');
+  const [errorMsg, setErrorMsg] = useState('');
+  const [errorBackStep, setErrorBackStep] = useState(null);
+
+  const [connections, setConnections] = useState([]);
+  const [selectedConnection, setSelectedConnection] = useState(null);
+
+  const [repos, setRepos] = useState([]);
+  const [selectedRepo, setSelectedRepo] = useState(null);
+
+  const [scanHistory, setScanHistory] = useState([]);
+  const [selectedScan, setSelectedScan] = useState(null);
+
+  const [selectedResultType, setSelectedResultType] = useState(null);
+  const [results, setResults] = useState(null);
+
+  const setError = (msg, backStep) => {
+    setErrorMsg(msg);
+    setErrorBackStep(backStep);
+    setStep(STEPS.ERROR);
+  };
+
+  // ── Step 1: validate connection on mount ──
+  useEffect(() => {
+    validateConnectionOnMount({ STEPS, setError, setConnections, setStep });
+  }, []);
+
+  // ── Step 2: connection selected → fetch repos ──
+  const handleSelectConnection = (item) =>
+    _handleSelectConnection({ STEPS, item, setSelectedConnection, setStep, setLoadingMsg, setError, setRepos });
+
+  // ── Step 3: repo selected → fetch scan history ──
+  const handleSelectRepo = (item) =>
+    _handleSelectRepo({ STEPS, item, setSelectedRepo, setStep, setLoadingMsg, setError, setScanHistory });
+
+  // ── Step 4: scan selected → show result type menu ──
+  const handleSelectScan = (item) =>
+    _handleSelectScan({ STEPS, item, setSelectedScan, setStep });
+
+  // ── Step 5: result type selected → fetch exactly one endpoint ──
+  const handleSelectResultType = (item) =>
+    _handleSelectResultType({ STEPS, item, selectedRepo, selectedScan, setSelectedResultType, setStep, setLoadingMsg, setError, setResults });
+
+  // ── Back navigation ──
+  const goBack = {
+    [STEPS.SELECT_CONNECTION]: () => exit(),
+    [STEPS.SELECT_REPO]:       () => { setSelectedConnection(null); setStep(STEPS.SELECT_CONNECTION); },
+    [STEPS.SELECT_SCAN]:       () => { setSelectedRepo(null); setStep(STEPS.SELECT_REPO); },
+    [STEPS.SELECT_RESULT_TYPE]:() => { setSelectedScan(null); setStep(STEPS.SELECT_SCAN); },
+    [STEPS.SHOWING_RESULTS]:   () => { setResults(null); setSelectedResultType(null); setStep(STEPS.SELECT_RESULT_TYPE); },
+  };
+
+  const breadcrumbParts = [
+    selectedConnection?.organizationName,
+    selectedRepo?.name,
+    selectedScan ? (selectedScan.commitId || '').slice(0, 8) : null,
+  ].filter(Boolean);
+
+  // ─── Render ───────────────────────────────────────────────────────────────
+
+  if (step === STEPS.LOADING) {
+    return ce(Box, { paddingX: 1, paddingY: 1 }, ce(Spinner, { label: loadingMsg }));
+  }
+
+  if (step === STEPS.ERROR) {
+    const canGoBack = errorBackStep !== null;
+    const onErrorBack = canGoBack
+      ? () => { setErrorMsg(''); setStep(errorBackStep); }
+      : () => exit();
+    return ce(ErrorView, { message: errorMsg, onBack: onErrorBack, canGoBack });
+  }
+
+  if (step === STEPS.SELECT_CONNECTION) {
+    const items = connections
+      .filter((c) => c && c.organizationName)
+      .map((c) => ({
+        label: c.organizationName,
+        sublabel: `${c.service}  ${c.baseUrl}`,
+        value: c,
+      }));
+    return ce(SelectList, {
+      title: 'Select a connection',
+      items,
+      onSelect: handleSelectConnection,
+      onBack: goBack[STEPS.SELECT_CONNECTION],
+    });
+  }
+
+  if (step === STEPS.SELECT_REPO) {
+    const items = repos
+      .filter((r) => r && (r.name || r.full_name))
+      .map((r) => ({
+        label: r.name || r.full_name,
+        sublabel: r.pushed_at ? `Last push: ${new Date(r.pushed_at).toLocaleDateString()}` : undefined,
+        value: r,
+      }));
+    return ce(
+      Box,
+      { flexDirection: 'column' },
+      ce(Box, { paddingX: 1 }, ce(Breadcrumb, { parts: [selectedConnection.organizationName] })),
+      ce(SelectList, {
+        title: 'Select a repository',
+        items,
+        onSelect: handleSelectRepo,
+        onBack: goBack[STEPS.SELECT_REPO],
+        emptyMessage: 'No repositories found for this organisation.',
+      })
+    );
+  }
+
+  if (step === STEPS.SELECT_SCAN) {
+    const items = scanHistory
+      .filter((s) => s && typeof s === 'object' && s.latest_commit_sha)
+      .slice()
+      .sort((a, b) => {
+        const da = new Date(a.timestamp || a.date || a.created_at || 0);
+        const db = new Date(b.timestamp || b.date || b.created_at || 0);
+        return db - da;
+      })
+      .map((s) => {
+        const date = s.timestamp || s.date || s.created_at;
+        const branch = s.branch || s.ref || '';
+        const commitFull = s.latest_commit_sha || '';
+        return {
+          label: branch || '(no branch)',
+          sublabel: [commitFull || null, date ? new Date(date).toLocaleString() : null].filter(Boolean).join('   '),
+          value: { ...s, commitId: commitFull },
+        };
+      });
+    return ce(
+      Box,
+      { flexDirection: 'column' },
+      ce(Box, { paddingX: 1 },
+        ce(Breadcrumb, { parts: [selectedConnection.organizationName, selectedRepo.name] })),
+      ce(SelectList, {
+        title: 'Select a scan',
+        items,
+        onSelect: handleSelectScan,
+        onBack: goBack[STEPS.SELECT_SCAN],
+        emptyMessage: 'No scan history found for this repository.',
+      })
+    );
+  }
+
+  if (step === STEPS.SELECT_RESULT_TYPE) {
+    const items = RESULT_TYPES.map((rt) => ({
+      label: rt.label,
+      sublabel: rt.kind === 'basic' ? 'standard analysis'
+              : rt.kind === 'advanced' ? 'advanced analysis'
+              : 'dismissed',
+      value: rt,
+    }));
+    return ce(
+      Box,
+      { flexDirection: 'column' },
+      ce(Box, { paddingX: 1 }, ce(Breadcrumb, { parts: breadcrumbParts })),
+      ce(SelectList, {
+        title: 'Select result type',
+        items,
+        onSelect: handleSelectResultType,
+        onBack: goBack[STEPS.SELECT_RESULT_TYPE],
+      })
+    );
+  }
+
+  if (step === STEPS.SHOWING_RESULTS) {
+    const issues = results?.issues || [];
+    const rtObj = RESULT_TYPES.find((r) => r.value === selectedResultType?.value);
+    return ce(ResultsView, {
+      issues,
+      resultTypeLabel: rtObj?.label || selectedResultType?.value || '',
+      breadcrumbParts,
+      onBack: goBack[STEPS.SHOWING_RESULTS],
+    });
+  }
+
+  return null;
+}

package/src/components/SelectList.js

@@ -0,0 +1,80 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+
+const PAGE_SIZE = 15;
+
+const ce = React.createElement;
+
+export default function SelectList({ items = [], title, onSelect, onBack, emptyMessage = 'No items.' }) {
+  const [cursor, setCursor] = useState(0);
+  const [windowStart, setWindowStart] = useState(0);
+
+  useInput((input, key) => {
+    if (items.length === 0) {
+      if (input === 'b' || key.escape) onBack?.();
+      return;
+    }
+    if (key.upArrow) {
+      const next = Math.max(0, cursor - 1);
+      setCursor(next);
+      if (next < windowStart) setWindowStart(next);
+    } else if (key.downArrow) {
+      const next = Math.min(items.length - 1, cursor + 1);
+      setCursor(next);
+      if (next >= windowStart + PAGE_SIZE) setWindowStart(next - PAGE_SIZE + 1);
+    } else if (key.return) {
+      onSelect(items[cursor]);
+    } else if (input === 'b' || key.escape) {
+      onBack?.();
+    }
+  });
+
+  const visible = items.slice(windowStart, windowStart + PAGE_SIZE);
+
+  const rows = items.length === 0
+    ? [ce(Text, { key: 'empty', color: 'gray' }, emptyMessage)]
+    : visible.map((item, i) => {
+        const idx = windowStart + i;
+        const selected = idx === cursor;
+        return ce(
+          Box,
+          { key: idx, flexDirection: 'column' },
+          ce(
+            Box,
+            { key: 'row' },
+            ce(Text, { color: selected ? 'cyan' : undefined }, selected ? '▶ ' : '  '),
+            ce(Text, { color: selected ? 'cyan' : undefined, bold: selected }, item.label)
+          ),
+          item.sublabel
+            ? ce(Text, { key: 'sub', color: 'gray', dimColor: true }, '    ' + item.sublabel)
+            : null
+        );
+      });
+
+  const counter = items.length > PAGE_SIZE
+    ? ce(
+        Box,
+        { key: 'counter', marginTop: 1 },
+        ce(Text, { color: 'gray', dimColor: true },
+          `${windowStart + 1}–${Math.min(windowStart + PAGE_SIZE, items.length)} of ${items.length}`)
+      )
+    : null;
+
+  const footer = ce(
+    Box,
+    { key: 'footer', marginTop: 1, borderStyle: 'single', borderColor: 'gray', paddingX: 1 },
+    ce(Text, { color: 'gray' },
+      (items.length > 0 ? '[↑↓] navigate   [Enter] select' : '') +
+      (onBack ? '   [b] back' : '')
+    )
+  );
+
+  return ce(
+    Box,
+    { flexDirection: 'column', paddingX: 1 },
+    ce(Box, { key: 'title', marginBottom: 1 }, ce(Text, { bold: true, color: 'cyan' }, title)),
+    ...rows,
+    counter,
+    footer
+  );
+}

package/src/index.js

@@ -13,10 +13,12 @@ import Login from './commands/login.js';
 import Logout from './commands/logout.js';
 import Review from './commands/review.js';
 import { runReviewHeadless } from './reviewHeadless.js';
+import ScanCenter from './components/ScanCenter.js';
 import Welcome from './components/Welcome.js';
 import * as scm from './scm/index.js';
 import { setConfigValue } from './utils/config.js';
 import { track, shutdown as analyticsShutdown, isTelemetryDisabled } from './utils/analytics.js';
+import registerScansCommands from './commands/scans/index.js';
 
 // Read version from package.json
 const require = createRequire(import.meta.url);
@@ -206,6 +208,13 @@ program
       render(React.createElement(Login));
     });
 
+  program
+    .command('scan-center')
+    .description('Browse scan results interactively')
+    .action(() => {
+      render(React.createElement(ScanCenter));
+    });
+
   program
     .command('logout')
     .description('Logout from CodeAnt')
@@ -376,6 +385,9 @@ program
       }));
     });
 
+  // ─── Scans commands ───
+  registerScansCommands(program, { runCmd });
+
   // ─── Telemetry control ───
   program
     .command('set-telemetry <enabled>')

package/src/scanCenter/handleSelectConnection.js

@@ -0,0 +1,14 @@
+import { listRepos } from '../scans/listRepos.js';
+
+export async function handleSelectConnection({ STEPS, item, setSelectedConnection, setStep, setLoadingMsg, setError, setRepos }) {
+  setSelectedConnection(item.value);
+  setStep(STEPS.LOADING);
+  setLoadingMsg(`Fetching repos for ${item.value.organizationName}…`);
+  const res = await listRepos(item.value.organizationName);
+  if (!res.success) {
+    setError(res.error || 'Failed to fetch repos', STEPS.SELECT_CONNECTION);
+    return;
+  }
+  setRepos(res.repos || []);
+  setStep(STEPS.SELECT_REPO);
+}

package/src/scanCenter/handleSelectRepo.js

@@ -0,0 +1,19 @@
+import { getScanHistory } from '../scans/getScanHistory.js';
+
+export async function handleSelectRepo({ STEPS, item, setSelectedRepo, setStep, setLoadingMsg, setError, setScanHistory }) {
+  setSelectedRepo(item.value);
+  setStep(STEPS.LOADING);
+  const repoFullName = item.value.full_name || item.value.name;
+  setLoadingMsg(`Loading scan history for ${repoFullName}…`);
+  const res = await getScanHistory(repoFullName);
+  if (!res.success) {
+    setError(res.error || 'Failed to fetch scan history', STEPS.SELECT_REPO);
+    return;
+  }
+  const history = res.scanHistory || [];
+  if (process.env.CODEANT_DEBUG_SCAN_HISTORY === '1') {
+    process.stderr.write('SCAN_HISTORY_SAMPLE: ' + JSON.stringify(history.slice(0, 15), null, 2) + '\n');
+  }
+  setScanHistory(history);
+  setStep(STEPS.SELECT_SCAN);
+}

package/src/scanCenter/handleSelectResultType.js

@@ -0,0 +1,34 @@
+import { fetchScanResults } from '../scans/fetchScanResults.js';
+import { fetchAdvancedScanResults } from '../scans/fetchAdvancedScanResults.js';
+import { fetchDismissedAlerts } from '../scans/fetchDismissedAlerts.js';
+
+export async function handleSelectResultType({ STEPS, item, selectedRepo, selectedScan, setSelectedResultType, setStep, setLoadingMsg, setError, setResults }) {
+  const rt = item.value;
+  setSelectedResultType(rt);
+  setStep(STEPS.LOADING);
+  setLoadingMsg(`Fetching ${item.label}…`);
+
+  const repo = selectedRepo.full_name;
+  const commitId = selectedScan.commitId;
+  let res;
+
+  if (rt.kind === 'basic') {
+    res = await fetchScanResults(repo, commitId, rt.value);
+  } else if (rt.kind === 'advanced') {
+    res = await fetchAdvancedScanResults(repo, commitId, rt.value);
+  } else if (rt.value === 'dismissed_alerts') {
+    const r = await fetchDismissedAlerts(repo, 'security');
+    res = r.success ? { success: true, issues: r.dismissedAlerts } : r;
+  } else if (rt.value === 'dismissed_secrets') {
+    const r = await fetchDismissedAlerts(repo, 'secrets');
+    res = r.success ? { success: true, issues: r.dismissedAlerts } : r;
+  }
+
+  if (!res || !res.success) {
+    setError((res && res.error) || 'Failed to fetch results', STEPS.SELECT_RESULT_TYPE);
+    return;
+  }
+
+  setResults(res);
+  setStep(STEPS.SHOWING_RESULTS);
+}

package/src/scanCenter/handleSelectScan.js

@@ -0,0 +1,4 @@
+export function handleSelectScan({ STEPS, item, setSelectedScan, setStep }) {
+  setSelectedScan(item.value);
+  setStep(STEPS.SELECT_RESULT_TYPE);
+}

package/src/scanCenter/validateConnectionOnMount.js

@@ -0,0 +1,15 @@
+import { validateConnection } from '../scans/connectionHandler.js';
+
+export async function validateConnectionOnMount({ STEPS, setError, setConnections, setStep }) {
+  const res = await validateConnection();
+  if (!res.success) {
+    setError(res.error || 'Failed to validate connection', null);
+    return;
+  }
+  if (!res.connections || res.connections.length === 0) {
+    setError('No connected organisations found. Please log in to CodeAnt first.', null);
+    return;
+  }
+  setConnections(res.connections);
+  setStep(STEPS.SELECT_CONNECTION);
+}

package/src/scans/connectionHandler.js

@@ -0,0 +1,52 @@
+import { fetchApi } from '../utils/fetchApi.js';
+
+/**
+ * Validate the stored API key with the CodeAnt backend.
+ *
+ * @returns {Promise<Object>}
+ * {
+ *   success: true,
+ *   connections: [
+ *     {
+ *       organizationName: "acme-corp",
+ *       baseUrl: "https://github.com",
+ *       service: "github" | "gitlab" | "azuredevops" | "bitbucket" | "unknown"
+ *     }
+ *   ],
+ *   email: "dev@acme.com",
+ * }
+ */
+export async function validateConnection() {
+  try {
+    const response = await fetchApi('/extension/scans2/validate', 'POST', {
+      extension: 'cli',
+    });
+
+    if (!response) {
+      return { success: false, error: 'Failed to connect to CodeAnt server' };
+    }
+
+    if (response.status === 'success' && response.data) {
+      const orgs = response.data.orgs || [];
+      return {
+        success: true,
+        connections: orgs.map((org) => ({
+          organizationName: org.organization_name,
+          baseUrl: org.base_url,
+          service: org.service || 'unknown',
+        })),
+        email: response.data.email,
+      };
+    }
+
+    return {
+      success: false,
+      error: response.message || 'Invalid or expired connection string',
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || 'Failed to validate connection string',
+    };
+  }
+}