securewithtrace 0.3.1 → 0.5.0

package/dist/index.js

@@ -3564,6 +3564,124 @@ function createAuthCommand() {
   return auth;
 }
 
+// src/banner.ts
+var ESC = "\x1B";
+var CURSOR_HIDE = `${ESC}[?25l`;
+var CURSOR_SHOW = `${ESC}[?25h`;
+function cursorUp(n) {
+  return n > 0 ? `${ESC}[${n}A` : "";
+}
+var RESET = `${ESC}[0m`;
+function rgb(r, g, b) {
+  return `${ESC}[38;2;${r};${g};${b}m`;
+}
+var LETTERS = {
+  T: ["########", "########", "   ##   ", "   ##   ", "   ##   ", "   ##   ", "   ##   "],
+  R: ["######  ", "##   ## ", "##   ## ", "######  ", "## ##   ", "##  ##  ", "##   ## "],
+  A: ["  ####  ", " ##  ## ", "##    ##", "########", "##    ##", "##    ##", "##    ##"],
+  C: [" ###### ", "##    ##", "##      ", "##      ", "##      ", "##    ##", " ###### "],
+  E: ["########", "##      ", "##      ", "######  ", "##      ", "##      ", "########"]
+};
+var LETTER_ORDER = ["T", "R", "A", "C", "E"];
+var LETTER_GAP = "  ";
+var ROWS = 7;
+function buildGrid() {
+  const rows = [];
+  for (let r = 0; r < ROWS; r++) {
+    const parts = [];
+    for (let i = 0; i < LETTER_ORDER.length; i++) {
+      const letter = LETTER_ORDER[i];
+      const def = LETTERS[letter];
+      if (def) {
+        parts.push(def[r] ?? "");
+      }
+      if (i < LETTER_ORDER.length - 1) {
+        parts.push(LETTER_GAP);
+      }
+    }
+    rows.push(parts.join(""));
+  }
+  return rows;
+}
+var SWEEP_CHARS = [" ", "\u2591", "\u2592", "\u2593", "\u2588"];
+var PALETTE = [
+  { r: 80, g: 200, b: 200 },
+  // bright teal
+  { r: 90, g: 210, b: 210 },
+  { r: 70, g: 190, b: 195 },
+  { r: 100, g: 220, b: 215 },
+  { r: 85, g: 205, b: 205 },
+  { r: 75, g: 195, b: 200 },
+  { r: 95, g: 215, b: 210 }
+];
+function renderFrame(grid, revealCol, sweepPhase) {
+  const lines = [];
+  for (let r = 0; r < grid.length; r++) {
+    const row = grid[r] ?? "";
+    let line = "";
+    const color = PALETTE[r % PALETTE.length] ?? { r: 80, g: 200, b: 200 };
+    line += rgb(color.r, color.g, color.b);
+    for (let c21 = 0; c21 < row.length; c21++) {
+      const ch = row[c21];
+      if (ch === " " || ch === void 0) {
+        line += " ";
+        continue;
+      }
+      if (c21 < revealCol) {
+        line += "\u2588";
+      } else if (c21 < revealCol + 4) {
+        const distFromEdge = c21 - revealCol;
+        const phaseIdx = Math.max(0, sweepPhase - distFromEdge);
+        line += SWEEP_CHARS[Math.min(phaseIdx, SWEEP_CHARS.length - 1)] ?? " ";
+      } else {
+        line += " ";
+      }
+    }
+    line += RESET;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function showBanner() {
+  const grid = buildGrid();
+  const totalCols = Math.max(...grid.map((r) => r.length));
+  if (!process.stdout.isTTY) {
+    printStaticBanner(grid);
+    return;
+  }
+  process.stdout.write(CURSOR_HIDE);
+  const emptyFrame = grid.map(() => "").join("\n");
+  process.stdout.write(`${emptyFrame}
+`);
+  const sweepWidth = 4;
+  const totalSteps = totalCols + sweepWidth + SWEEP_CHARS.length;
+  for (let step = 0; step <= totalSteps; step++) {
+    const revealCol = Math.max(0, step - SWEEP_CHARS.length);
+    const sweepPhase = Math.min(step, SWEEP_CHARS.length);
+    const frame = renderFrame(grid, revealCol, sweepPhase);
+    process.stdout.write(`${cursorUp(grid.length)}\r`);
+    process.stdout.write(`${frame}
+`);
+    await sleep2(12);
+  }
+  process.stdout.write(CURSOR_SHOW);
+}
+function printStaticBanner(grid) {
+  for (let r = 0; r < grid.length; r++) {
+    const row = grid[r] ?? "";
+    const color = PALETTE[r % PALETTE.length] ?? { r: 80, g: 200, b: 200 };
+    let line = rgb(color.r, color.g, color.b);
+    for (const ch of row) {
+      line += ch === "#" ? "\u2588" : " ";
+    }
+    line += RESET;
+    console.log(line);
+  }
+}
+
 // src/repo/commands.ts
 import { chmodSync, mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
@@ -23847,11 +23965,11 @@ async function resolveOrganizationIdSafe(client) {
 
 // src/repo/commands.ts
 function stripAnsi(str) {
-  const ESC = String.fromCharCode(27);
+  const ESC2 = String.fromCharCode(27);
   const CSI = String.fromCharCode(155);
   const BEL = String.fromCharCode(7);
-  const csi = `[${ESC}${CSI}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`;
-  const osc = `${ESC}\\].*?(?:${BEL}|${ESC}\\\\)`;
+  const csi = `[${ESC2}${CSI}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`;
+  const osc = `${ESC2}\\].*?(?:${BEL}|${ESC2}\\\\)`;
   const pattern = new RegExp(`${osc}|${csi}`, "g");
   return str.replace(pattern, "");
 }
@@ -24030,12 +24148,209 @@ function createRepoCommand() {
   return repo;
 }
 
+// src/vulnerabilities/commands.ts
+import { createInterface } from "readline";
+var SEVERITY_ORDER = {
+  CRITICAL: 0,
+  HIGH: 1,
+  MEDIUM: 2,
+  LOW: 3
+};
+var DEFAULT_PAGE_SIZE = 25;
+async function resolveRepositoryId(client, organizationId, repoIdentifier) {
+  const result = await client.repository.listRepositories({
+    params: { organizationId }
+  });
+  if (result.status !== 200) {
+    console.error(`Failed to list repositories (status ${result.status}).`);
+    process.exit(1);
+  }
+  const repos = result.body;
+  const match = repos.find((r) => {
+    const url2 = r.repositoryUrl;
+    if (url2.endsWith(`/${repoIdentifier}`)) {
+      return true;
+    }
+    if (url2.endsWith(`/${repoIdentifier}.git`)) {
+      return true;
+    }
+    if (url2 === repoIdentifier) {
+      return true;
+    }
+    return false;
+  });
+  if (match) {
+    return match.repositoryId;
+  }
+  const byName = repos.filter((r) => {
+    const segments = r.repositoryUrl.replace(/\.git$/, "").split("/");
+    const name = segments[segments.length - 1];
+    return name === repoIdentifier;
+  });
+  if (byName.length === 1 && byName[0]) {
+    return byName[0].repositoryId;
+  }
+  if (byName.length > 1) {
+    console.error(
+      `Ambiguous repository name '${repoIdentifier}'. Multiple matches found:
+${byName.map((r) => `  - ${r.repositoryUrl}`).join("\n")}
+Please use the full owner/repo format.`
+    );
+    process.exit(1);
+  }
+  console.error(
+    `Repository '${repoIdentifier}' not found.
+Run \`tracecli repo list\` to see available repositories.`
+  );
+  process.exit(1);
+}
+function formatSeverity(severity) {
+  switch (severity) {
+    case "CRITICAL":
+      return "CRIT";
+    case "HIGH":
+      return "HIGH";
+    case "MEDIUM":
+      return "MED";
+    case "LOW":
+      return "LOW";
+    default:
+      return severity;
+  }
+}
+function printVulnerabilities(vulnerabilities) {
+  const sorted = [...vulnerabilities].sort(
+    (a, b) => (SEVERITY_ORDER[a.severity] ?? 99) - (SEVERITY_ORDER[b.severity] ?? 99)
+  );
+  for (const vuln of sorted) {
+    const sev = formatSeverity(vuln.severity);
+    const status = vuln.status.toLowerCase().replace("_", " ");
+    const repo = vuln.repositoryName;
+    const file2 = vuln.codeSnippet.filePath;
+    const line = vuln.codeSnippet.startLine;
+    console.log(`  [${sev}] ${vuln.title}`);
+    console.log(`         ${repo} \xB7 ${file2}:${line} \xB7 ${status}`);
+    console.log(`         ${vuln.traceId}`);
+    console.log("");
+  }
+}
+async function promptContinue(displayed, total) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`Showing ${displayed} of ${total}. Show more? [Y/n] `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === "" || trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+function createListCommand2() {
+  return new Command("list").description("List vulnerabilities for your organization").option("--repo <repo>", "Filter by repository name or owner/repo").option(
+    "--severity <severity>",
+    "Filter by severity (CRITICAL, HIGH, MEDIUM, LOW)",
+    (value) => value.toUpperCase()
+  ).option(
+    "--status <status>",
+    "Filter by status (OPEN, IN_PROGRESS, FIXED, IGNORED, FALSE_POSITIVE)",
+    (value) => value.toUpperCase()
+  ).option("--page-size <size>", "Number of results per page", (v) => {
+    const n = Number.parseInt(v, 10);
+    if (Number.isNaN(n) || n < 1) {
+      throw new Error("--page-size must be a positive integer");
+    }
+    return Math.min(n, 200);
+  }).option("--json", "Output as JSON").action(
+    async (options) => {
+      const { token } = requireAuth();
+      const client = createClient(token);
+      const organizationId = await resolveOrganizationId(client);
+      const conditions = [];
+      if (options.repo) {
+        const repositoryId = await resolveRepositoryId(client, organizationId, options.repo);
+        conditions.push({ field: "repositoryId", operator: "eq", value: repositoryId });
+      }
+      if (options.severity) {
+        conditions.push({ field: "severity", operator: "eq", value: options.severity });
+      }
+      if (options.status) {
+        conditions.push({ field: "status", operator: "eq", value: options.status });
+      }
+      const filterBody = {
+        filters: conditions.length > 0 ? { operator: "and", conditions } : void 0,
+        defaultBranchOnly: true,
+        sortBy: "severity",
+        sortOrder: "desc"
+      };
+      const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+      let page = 1;
+      let totalDisplayed = 0;
+      let total = 0;
+      const allJsonVulnerabilities = [];
+      while (true) {
+        const result = await client.vulnerability.filterVulnerabilities({
+          params: { organizationId },
+          body: { ...filterBody, page, pageSize }
+        });
+        if (result.status !== 200) {
+          console.error(`Failed to list vulnerabilities (status ${result.status}).`);
+          process.exit(1);
+        }
+        total = result.body.total;
+        const vulnerabilities = result.body.statusGroups.flatMap((g) => g.vulnerabilities);
+        if (page === 1 && vulnerabilities.length === 0) {
+          if (options.json) {
+            console.log("[]");
+          } else {
+            console.log("No vulnerabilities found.");
+          }
+          return;
+        }
+        if (options.json) {
+          allJsonVulnerabilities.push(...vulnerabilities);
+        } else {
+          if (page === 1) {
+            console.log(`Found ${total} vulnerabilit${total === 1 ? "y" : "ies"}:
+`);
+          }
+          printVulnerabilities(vulnerabilities);
+        }
+        totalDisplayed += vulnerabilities.length;
+        if (totalDisplayed >= total || vulnerabilities.length < pageSize) {
+          break;
+        }
+        if (options.json) {
+          page++;
+          continue;
+        }
+        const wantMore = await promptContinue(totalDisplayed, total);
+        if (!wantMore) {
+          break;
+        }
+        page++;
+      }
+      if (options.json) {
+        console.log(JSON.stringify(allJsonVulnerabilities, null, 2));
+      }
+    }
+  );
+}
+function createVulnerabilitiesCommand() {
+  const vulnerabilities = new Command("vulnerabilities").description("Manage vulnerabilities");
+  vulnerabilities.addCommand(createListCommand2());
+  return vulnerabilities;
+}
+
 // src/index.ts
 var program2 = new Command();
 program2.name("tracecli").description("Trace CLI").version("0.0.1");
+program2.action(async () => {
+  await showBanner();
+  program2.outputHelp();
+});
 program2.command("echo").description("Echo a message back to the terminal").argument("<message...>", "message to echo").action((messageParts) => {
   console.log(messageParts.join(" "));
 });
 program2.addCommand(createAuthCommand());
 program2.addCommand(createRepoCommand());
+program2.addCommand(createVulnerabilitiesCommand());
 program2.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securewithtrace",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Trace CLI",
   "type": "module",
   "bin": {