@closeup1202/klag 0.2.0 → 0.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 > Know **why** your Kafka consumer lag is growing — in 5 seconds from the terminal
 
-[![npm version](https://badge.fury.io/js/klag.svg)](https://www.npmjs.com/package/klag)
+[![npm version](https://badge.fury.io/js/%40closeup1202%2Fklag.svg)](https://www.npmjs.com/package/@closeup1202/klag)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 ## Compared to existing tools
@@ -21,21 +21,21 @@ npx @closeup1202/klag --broker localhost:9092 --group my-service
 
 ## Output example
 ```
-⚡ klag  v0.1.0
+⚡ klag 0.3.0
 
 🔍 Consumer Group: my-service
    Broker:         localhost:9092
-   Collected At:   2026-03-26 17:27:27 (Asia/Seoul)
+   Collected At:   2026-03-28 17:27:27 (Asia/Seoul)
 
-   Group Status : ⚠️  WARNING   Total Lag : 1,234
+   Group Status : 🚨 CRITICAL   Total Lag : 1,234   Drain : ∞
 
-┌────────┬───────────┬──────────────────┬────────────────┬───────┬─────────┬──────────────┬──────────────┐
-│ Topic  │ Partition │ Committed Offset │ Log-End Offset │  Lag  │ Status  │ Produce Rate │ Consume Rate │
-├────────┼───────────┼──────────────────┼────────────────┼───────┼─────────┼──────────────┼──────────────┤
-│ orders │         0 │            8,796 │         10,000 │ 1,204 │ 🔴 HIGH │  40.0 msg/s  │   0.0 msg/s  │
-│ orders │         1 │            9,988 │         10,000 │    12 │ 🟢 OK   │   0.0 msg/s  │   0.0 msg/s  │
-│ orders │         2 │            9,982 │         10,000 │    18 │ 🟢 OK   │   0.0 msg/s  │   0.0 msg/s  │
-└────────┴───────────┴──────────────────┴────────────────┴───────┴─────────┴──────────────┴──────────────┘
+┌────────┬───────────┬──────────────────┬────────────────┬───────┬─────────┬──────┬──────────────┬──────────────┐
+│ Topic  │ Partition │ Committed Offset │ Log-End Offset │  Lag  │ Status  │ Drain│ Produce Rate │ Consume Rate │
+├────────┼───────────┼──────────────────┼────────────────┼───────┼─────────┼──────┼──────────────┼──────────────┤
+│ orders │         0 │            8,796 │         10,000 │ 1,204 │ 🔴 HIGH │    ∞ │  40.0 msg/s  │   0.0 msg/s  │
+│ orders │         1 │            9,988 │         10,000 │    12 │ 🟢 OK   │    — │   0.0 msg/s  │   0.0 msg/s  │
+│ orders │         2 │            9,982 │         10,000 │    18 │ 🟢 OK   │    — │   0.0 msg/s  │   0.0 msg/s  │
+└────────┴───────────┴──────────────────┴────────────────┴───────┴─────────┴──────┴──────────────┴──────────────┘
 
 🔎 Root Cause Analysis
    [PRODUCER_BURST] orders
@@ -156,8 +156,9 @@ All consumption pauses during rebalancing, which can cause a temporary lag spike
 
 - [x] v0.1.0 — lag collection, hot partition, producer burst, slow consumer, rebalancing detection, watch mode with lag trend (▲▼)
 - [x] v0.2.0 — SSL/SASL authentication, `.klagrc` config file support
-- [ ] v0.3.0 — multi-group monitoring
-- [ ] v0.4.0 — Slack alerts, Prometheus export
+- [x] v0.3.0 — time-to-drain severity classification, Drain column per partition
+- [ ] v0.4.0 — multi-group monitoring
+- [ ] v0.5.0 — Slack alerts, Prometheus export
 
 ## License
 

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { Command } from "commander";
 
 // src/analyzer/burstDetector.ts
@@ -363,12 +363,30 @@ import chalk from "chalk";
 import Table from "cli-table3";
 
 // src/types/index.ts
-var VERSION = "0.2.0";
-function classifyLag(lag) {
-  if (lag < 100n) return "OK";
-  if (lag < 1000n) return "WARN";
+var VERSION = "0.3.1";
+function classifyLag(lag, consumeRate) {
+  if (lag === 0n) return "OK";
+  if (consumeRate !== void 0) {
+    if (consumeRate === 0) return "HIGH";
+    const drainSec = Number(lag) / consumeRate;
+    if (drainSec < 60) return "OK";
+    if (drainSec < 300) return "WARN";
+    return "HIGH";
+  }
+  if (lag < 10000n) return "OK";
+  if (lag < 100000n) return "WARN";
   return "HIGH";
 }
+function formatDrainTime(lag, consumeRate) {
+  if (lag === 0n) return "\u2014";
+  if (consumeRate === 0) return "\u221E";
+  const sec = Math.ceil(Number(lag) / consumeRate);
+  if (sec < 60) return `${sec}s`;
+  const m = Math.floor(sec / 60);
+  const s = sec % 60;
+  if (sec < 3600) return s > 0 ? `${m}m${s}s` : `${m}m`;
+  return `>${Math.floor(sec / 3600)}h`;
+}
 
 // src/reporter/tableReporter.ts
 var LEVEL_ICON = {
@@ -388,8 +406,8 @@ function formatTrend(lagDiff) {
   if (lagDiff > 0n) return chalk.red(`\u25B2 +${lagDiff.toLocaleString()}`);
   return chalk.green(`\u25BC ${lagDiff.toLocaleString()}`);
 }
-function groupStatus(totalLag) {
-  const level = classifyLag(totalLag);
+function groupStatus(totalLag, totalConsumeRate) {
+  const level = classifyLag(totalLag, totalConsumeRate);
   if (level === "OK") return chalk.green("\u2705 OK");
   if (level === "WARN") return chalk.yellow("\u26A0\uFE0F  WARNING");
   return chalk.red("\u{1F6A8} CRITICAL");
@@ -418,18 +436,25 @@ function printLagTable(snapshot, rcaResults = [], rateSnapshot, watchMode = fals
     chalk.bold("   Collected At:   ") + chalk.gray(`${localTime} (${tz})`)
   );
   console.log("");
-  const status = groupStatus(totalLag);
-  const totalStr = chalk.bold(formatLag(totalLag));
-  console.log(`   Group Status : ${status}   Total Lag : ${totalStr}`);
-  console.log("");
   const hasRate = !!rateSnapshot && rateSnapshot.partitions.length > 0;
   const hasTrend = watchMode;
   const rateMap = /* @__PURE__ */ new Map();
+  let totalConsumeRate;
   if (hasRate && rateSnapshot) {
+    let sum = 0;
     for (const r of rateSnapshot.partitions) {
       rateMap.set(`${r.topic}-${r.partition}`, r);
+      sum += r.consumeRate;
     }
+    totalConsumeRate = sum;
   }
+  const status = groupStatus(totalLag, totalConsumeRate);
+  const totalStr = chalk.bold(formatLag(totalLag));
+  const drainStr = totalConsumeRate !== void 0 ? `   Drain : ${chalk.cyan(formatDrainTime(totalLag, totalConsumeRate))}` : "";
+  console.log(
+    `   Group Status : ${status}   Total Lag : ${totalStr}${drainStr}`
+  );
+  console.log("");
   const head = [
     chalk.bold("Topic"),
     chalk.bold("Partition"),
@@ -438,7 +463,11 @@ function printLagTable(snapshot, rcaResults = [], rateSnapshot, watchMode = fals
     chalk.bold("Lag"),
     ...hasTrend ? [chalk.bold("Trend")] : [],
     chalk.bold("Status"),
-    ...hasRate ? [chalk.bold("Produce Rate"), chalk.bold("Consume Rate")] : []
+    ...hasRate ? [
+      chalk.bold("Drain"),
+      chalk.bold("Produce Rate"),
+      chalk.bold("Consume Rate")
+    ] : []
   ];
   const table = new Table({
     head,
@@ -450,16 +479,19 @@ function printLagTable(snapshot, rcaResults = [], rateSnapshot, watchMode = fals
       "right",
       ...hasTrend ? ["right"] : [],
       "center",
-      ...hasRate ? ["right", "right"] : []
+      ...hasRate ? ["right", "right", "right"] : []
     ],
     style: { head: [], border: ["grey"] }
   });
   let lastTopic = "";
   for (const p of partitions) {
-    const level = classifyLag(p.lag);
-    const lagStr = level === "HIGH" ? chalk.red(formatLag(p.lag)) : level === "WARN" ? chalk.yellow(formatLag(p.lag)) : chalk.green(formatLag(p.lag));
     const rateEntry = rateMap.get(`${p.topic}-${p.partition}`);
+    const level = classifyLag(p.lag, rateEntry?.consumeRate);
+    const lagStr = level === "HIGH" ? chalk.red(formatLag(p.lag)) : level === "WARN" ? chalk.yellow(formatLag(p.lag)) : chalk.green(formatLag(p.lag));
     const rateColumns = hasRate ? [
+      chalk.cyan(
+        rateEntry !== void 0 ? formatDrainTime(p.lag, rateEntry.consumeRate) : "\u2014"
+      ),
       chalk.yellow(formatRate(rateEntry?.produceRate ?? 0)),
       chalk.cyan(formatRate(rateEntry?.consumeRate ?? 0))
     ] : [];
@@ -614,6 +646,104 @@ function parseConfig(filePath) {
   return obj;
 }
 
+// src/cli/groupPicker.ts
+import chalk4 from "chalk";
+import prompts from "prompts";
+var GROUP_STATE_ORDER = {
+  Stable: 0,
+  Empty: 1,
+  PreparingRebalance: 2,
+  CompletingRebalance: 3,
+  Dead: 4
+};
+async function pickGroup(options) {
+  const kafka = createKafkaClient("klag-picker", { ...options, groupId: "" });
+  const admin = kafka.admin();
+  process.stdout.write(chalk4.gray("  Fetching consumer groups..."));
+  let groups = [];
+  try {
+    await admin.connect();
+    const result = await admin.listGroups();
+    groups = result.groups;
+  } finally {
+    await admin.disconnect();
+  }
+  process.stdout.write(`\r${" ".repeat(40)}\r`);
+  if (groups.length === 0) {
+    console.error(chalk4.red("\n\u274C No consumer groups found on this broker\n"));
+    process.exit(1);
+  }
+  const kafka2 = createKafkaClient("klag-picker-desc", {
+    ...options,
+    groupId: ""
+  });
+  const admin2 = kafka2.admin();
+  process.stdout.write(chalk4.gray("  Loading group states...  "));
+  const stateMap = /* @__PURE__ */ new Map();
+  try {
+    await admin2.connect();
+    const groupIds = groups.map((g) => g.groupId);
+    const described = await admin2.describeGroups(groupIds);
+    for (const g of described.groups) {
+      stateMap.set(g.groupId, g.state);
+    }
+  } catch {
+  } finally {
+    await admin2.disconnect();
+  }
+  process.stdout.write(`\r${" ".repeat(40)}\r`);
+  const sorted = [...groups].sort((a, b) => {
+    const stateA = GROUP_STATE_ORDER[stateMap.get(a.groupId) ?? ""] ?? 99;
+    const stateB = GROUP_STATE_ORDER[stateMap.get(b.groupId) ?? ""] ?? 99;
+    return stateA !== stateB ? stateA - stateB : a.groupId.localeCompare(b.groupId);
+  });
+  const choices = sorted.map((g) => {
+    const state = stateMap.get(g.groupId);
+    const stateLabel = state ? stateColor(state) : chalk4.gray("unknown");
+    return {
+      title: `${g.groupId}  ${stateLabel}`,
+      value: g.groupId
+    };
+  });
+  console.log("");
+  const response = await prompts(
+    {
+      type: "autocomplete",
+      name: "groupId",
+      message: "Select a consumer group",
+      choices,
+      suggest: (input, choices2) => Promise.resolve(
+        choices2.filter(
+          (c) => c.value.toLowerCase().includes(input.toLowerCase())
+        )
+      )
+    },
+    {
+      onCancel: () => {
+        console.log(chalk4.gray("\n  Cancelled\n"));
+        process.exit(0);
+      }
+    }
+  );
+  console.log("");
+  return response.groupId;
+}
+function stateColor(state) {
+  switch (state) {
+    case "Stable":
+      return chalk4.green(`(${state})`);
+    case "Empty":
+      return chalk4.gray(`(${state})`);
+    case "PreparingRebalance":
+    case "CompletingRebalance":
+      return chalk4.yellow(`(${state})`);
+    case "Dead":
+      return chalk4.red(`(${state})`);
+    default:
+      return chalk4.gray(`(${state})`);
+  }
+}
+
 // src/cli/validators.ts
 import { existsSync as existsSync2 } from "fs";
 import { InvalidArgumentError } from "commander";
@@ -667,7 +797,7 @@ function parseCertPath(value) {
 }
 
 // src/cli/watcher.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var MAX_RETRIES = 3;
 function clearScreen() {
   process.stdout.write("\x1Bc");
@@ -683,31 +813,31 @@ function printWatchHeader(intervalMs, updatedAt) {
     hour12: false
   });
   console.log(
-    chalk4.bold.cyan("\u26A1 klag") + chalk4.gray(`  v${VERSION}`) + "  \u2502  " + chalk4.yellow("watch mode") + "  \u2502  " + chalk4.gray(`${intervalSec}s refresh`) + "  \u2502  " + chalk4.gray("Ctrl+C to exit")
+    chalk5.bold.cyan("\u26A1 klag") + chalk5.gray(`  v${VERSION}`) + "  \u2502  " + chalk5.yellow("watch mode") + "  \u2502  " + chalk5.gray(`${intervalSec}s refresh`) + "  \u2502  " + chalk5.gray("Ctrl+C to exit")
   );
-  console.log(chalk4.gray(`   Last updated: ${timeStr} (${tz})`));
+  console.log(chalk5.gray(`   Last updated: ${timeStr} (${tz})`));
 }
 function printWatchError(message, retryCount, retryIn) {
   clearScreen();
   console.log(
-    chalk4.bold.cyan("\u26A1 klag") + chalk4.gray(`  v${VERSION}`) + "  \u2502  " + chalk4.yellow("watch mode") + "  \u2502  " + chalk4.gray("Ctrl+C to exit")
+    chalk5.bold.cyan("\u26A1 klag") + chalk5.gray(`  v${VERSION}`) + "  \u2502  " + chalk5.yellow("watch mode") + "  \u2502  " + chalk5.gray("Ctrl+C to exit")
   );
   console.log("");
-  console.error(chalk4.red(`   \u274C Error: ${message}`));
+  console.error(chalk5.red(`   \u274C Error: ${message}`));
   console.log(
-    chalk4.yellow(`   Retrying ${retryCount}/${MAX_RETRIES}... in ${retryIn}s`)
+    chalk5.yellow(`   Retrying ${retryCount}/${MAX_RETRIES}... in ${retryIn}s`)
   );
   console.log("");
 }
 function printWatchFatal(message) {
   clearScreen();
   console.log(
-    chalk4.bold.cyan("\u26A1 klag") + chalk4.gray(`  v${VERSION}`) + "  \u2502  " + chalk4.yellow("watch mode")
+    chalk5.bold.cyan("\u26A1 klag") + chalk5.gray(`  v${VERSION}`) + "  \u2502  " + chalk5.yellow("watch mode")
   );
   console.log("");
-  console.error(chalk4.red(`   \u274C Error: ${message}`));
+  console.error(chalk5.red(`   \u274C Error: ${message}`));
   console.error(
-    chalk4.red(`   All ${MAX_RETRIES} retries failed \u2014 exiting watch mode`)
+    chalk5.red(`   All ${MAX_RETRIES} retries failed \u2014 exiting watch mode`)
   );
   console.log("");
 }
@@ -730,7 +860,7 @@ async function runOnce(options, noRate, previous) {
     const topics = [...new Set(snapshot.partitions.map((p) => p.topic))];
     const waitSec = (options.intervalMs ?? 5e3) / 1e3;
     process.stdout.write(
-      chalk4.gray(`  Sampling rates... (waiting ${waitSec}s)   `)
+      chalk5.gray(`  Sampling rates... (waiting ${waitSec}s)   `)
     );
     rateSnapshot = await collectRate(options, topics);
     process.stdout.write(`\r${" ".repeat(50)}\r`);
@@ -747,7 +877,7 @@ function printCountdown(seconds) {
     let remaining = seconds;
     const tick = () => {
       process.stdout.write(
-        `\r${chalk4.gray(`   [\u25CF] Next refresh in ${remaining}s...`)}   `
+        `\r${chalk5.gray(`   [\u25CF] Next refresh in ${remaining}s...`)}   `
       );
       if (remaining === 0) {
         process.stdout.write(`\r${" ".repeat(40)}\r`);
@@ -772,12 +902,12 @@ function getFriendlyMessage(err, broker) {
 }
 async function startWatch(options, noRate) {
   process.on("SIGINT", () => {
-    console.log(chalk4.gray("\n\n  Watch mode exited\n"));
+    console.log(chalk5.gray("\n\n  Watch mode exited\n"));
     process.exit(0);
   });
   const intervalMs = options.intervalMs ?? 5e3;
   const waitSec = Math.ceil(intervalMs / 1e3);
-  process.stdout.write(chalk4.gray("  Connecting to broker..."));
+  process.stdout.write(chalk5.gray("  Connecting to broker..."));
   let errorCount = 0;
   let previousSnapshot;
   while (true) {
@@ -808,7 +938,10 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
   "Kafka broker address",
   parseBroker,
   "localhost:9092"
-).requiredOption("-g, --group <groupId>", "Consumer group ID").option(
+).option(
+  "-g, --group <groupId>",
+  "Consumer group ID (omit to pick interactively)"
+).option(
   "-i, --interval <ms>",
   "Rate sampling interval in ms",
   parseInterval,
@@ -833,12 +966,11 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
     const rc = loaded?.config ?? {};
     if (loaded) {
       process.stderr.write(
-        chalk5.gray(`  Using config: ${loaded.loadedFrom}
+        chalk6.gray(`  Using config: ${loaded.loadedFrom}
 `)
       );
     }
     const broker = options.broker !== "localhost:9092" ? options.broker : rc.broker ?? options.broker;
-    const groupId = options.group ?? rc.group;
     const intervalMs = options.interval !== 5e3 ? options.interval : rc.interval ?? options.interval;
     const timeoutMs = options.timeout !== 5e3 ? options.timeout : rc.timeout ?? options.timeout;
     const auth = buildAuthOptions({
@@ -850,18 +982,14 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
       saslUsername: options.saslUsername ?? rc.sasl?.username,
       saslPassword: options.saslPassword ?? rc.sasl?.password
     });
-    const kafkaOptions = {
-      broker,
-      groupId,
-      intervalMs,
-      timeoutMs,
-      ...auth
-    };
+    const baseOptions = { broker, intervalMs, timeoutMs, ...auth };
+    const groupId = options.group ?? rc.group ?? await pickGroup(baseOptions);
+    const kafkaOptions = { ...baseOptions, groupId };
     if (options.watch) {
       await startWatch(kafkaOptions, options.rate === false);
       return;
     }
-    process.stdout.write(chalk5.gray("  Connecting to broker..."));
+    process.stdout.write(chalk6.gray("  Connecting to broker..."));
     const snapshot = await collectLag(kafkaOptions);
     process.stdout.write(`\r${" ".repeat(50)}\r`);
     let rateSnapshot;
@@ -869,7 +997,7 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
       const topics = [...new Set(snapshot.partitions.map((p) => p.topic))];
       const waitSec = (kafkaOptions.intervalMs ?? 5e3) / 1e3;
       process.stdout.write(
-        chalk5.gray(`  Sampling rates... (waiting ${waitSec}s)   `)
+        chalk6.gray(`  Sampling rates... (waiting ${waitSec}s)   `)
       );
       rateSnapshot = await collectRate(kafkaOptions, topics);
       process.stdout.write(`\r${" ".repeat(50)}\r`);
@@ -897,14 +1025,14 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
     process.stdout.write(`\r${" ".repeat(50)}\r`);
     const message = err instanceof Error ? err.message : String(err);
     if (message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("Connection error") || message.includes("connect ECONNREFUSED")) {
-      console.error(chalk5.red(`
+      console.error(chalk6.red(`
 \u274C Cannot connect to broker
 `));
-      console.error(chalk5.yellow("   Check the following:"));
-      console.error(chalk5.gray(`   \u2022 Is Kafka running: docker ps`));
-      console.error(chalk5.gray(`   \u2022 Broker address: ${options.broker}`));
+      console.error(chalk6.yellow("   Check the following:"));
+      console.error(chalk6.gray(`   \u2022 Is Kafka running: docker ps`));
+      console.error(chalk6.gray(`   \u2022 Broker address: ${options.broker}`));
       console.error(
-        chalk5.gray(
+        chalk6.gray(
           `   \u2022 Port accessibility: nc -zv ${options.broker.split(":")[0]} ${options.broker.split(":")[1]}`
         )
       );
@@ -912,18 +1040,18 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
       process.exit(1);
     }
     if (message.includes("SASLAuthenticationFailed") || message.includes("Authentication failed") || message.includes("SASL")) {
-      console.error(chalk5.red(`
+      console.error(chalk6.red(`
 \u274C SASL authentication failed
 `));
-      console.error(chalk5.yellow("   Check the following:"));
+      console.error(chalk6.yellow("   Check the following:"));
       console.error(
-        chalk5.gray(`   \u2022 Mechanism: ${options.saslMechanism ?? "(none)"}`)
+        chalk6.gray(`   \u2022 Mechanism: ${options.saslMechanism ?? "(none)"}`)
       );
       console.error(
-        chalk5.gray(`   \u2022 Username:  ${options.saslUsername ?? "(none)"}`)
+        chalk6.gray(`   \u2022 Username:  ${options.saslUsername ?? "(none)"}`)
       );
       console.error(
-        chalk5.gray(
+        chalk6.gray(
           `   \u2022 Password:  set via KLAG_SASL_PASSWORD or --sasl-password`
         )
       );
@@ -931,21 +1059,21 @@ program.name("klag").description("Kafka consumer lag root cause analyzer").versi
       process.exit(1);
     }
     if (message.includes("not found") || message.includes("Dead state")) {
-      console.error(chalk5.red(`
+      console.error(chalk6.red(`
 \u274C Consumer group not found
 `));
-      console.error(chalk5.yellow("   Check the following:"));
-      console.error(chalk5.gray(`   \u2022 Group ID: ${options.group}`));
-      console.error(chalk5.gray(`   \u2022 List existing groups:`));
+      console.error(chalk6.yellow("   Check the following:"));
+      console.error(chalk6.gray(`   \u2022 Group ID: ${options.group}`));
+      console.error(chalk6.gray(`   \u2022 List existing groups:`));
       console.error(
-        chalk5.gray(
+        chalk6.gray(
           `     kafka-consumer-groups.sh --bootstrap-server ${options.broker} --list`
         )
       );
       console.error("");
       process.exit(1);
     }
-    console.error(chalk5.red(`
+    console.error(chalk6.red(`
 \u274C Error: ${message}
 `));
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@closeup1202/klag",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Kafka consumer lag root cause analyzer",
   "type": "module",
   "bin": {
@@ -39,11 +39,13 @@
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.3",
-    "kafkajs": "^2.2.4"
+    "kafkajs": "^2.2.4",
+    "prompts": "^2.4.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.8",
     "@types/node": "^25.5.0",
+    "@types/prompts": "^2.4.9",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",