securewithtrace 0.3.0 → 0.4.0

package/dist/index.js

@@ -23985,12 +23985,11 @@ function createCloneCommand() {
       }
       args.push("--", effectiveUrl, targetDir);
       console.log(`Cloning ${cloneUrl} into ${targetDir}...`);
-      const extraEnv = {
-        GIT_TERMINAL_PROMPT: "0"
-      };
+      const extraEnv = {};
       if (installationToken) {
         askPassScript = createAskPassScript(installationToken);
         extraEnv["GIT_ASKPASS"] = askPassScript;
+        extraEnv["GIT_TERMINAL_PROMPT"] = "0";
       }
       try {
         const proc = Bun.spawn(["git", ...args], {
@@ -24031,6 +24030,198 @@ 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");
@@ -24039,4 +24230,5 @@ program2.command("echo").description("Echo a message back to the terminal").argu
 });
 program2.addCommand(createAuthCommand());
 program2.addCommand(createRepoCommand());
+program2.addCommand(createVulnerabilitiesCommand());
 program2.parse();

package/package.json

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