@lizard-build/cli 0.3.42 → 0.3.44

package/src/commands/metrics.ts

@@ -0,0 +1,390 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { api, withScope, withQuery, APIError, type ResourceScope } from "../lib/api.js";
+import { getProjectLink } from "../lib/config.js";
+import { resolveProjectScope, getActiveServiceWithKind } from "../lib/resolve.js";
+import { info, error, isJSONMode, printJSON, table, timeAgo } from "../lib/format.js";
+
+// Shapes returned by /api/apps/:id/metrics and /api/projects/:id/metrics.
+// Units: series cpu = vCPUs, memory/disk_used/disk_total = bytes,
+// network_rx/tx + disk_read/write = bytes/s; latest mem is in MB.
+interface SeriesItem {
+  metric: string;
+  timestamps: number[]; // seconds
+  values: number[];
+}
+
+interface LatestMetrics {
+  cpu: number; // vCPUs in use
+  memUsedMb: number;
+  memTotalMb: number;
+  sampledAt: number; // ms
+}
+
+interface EntityMetricsResult {
+  series: SeriesItem[];
+  latest: LatestMetrics | null;
+  limits: { cpuMillis: number; memoryMi: number };
+}
+
+interface ProjectEntityMetrics extends EntityMetricsResult {
+  id: string;
+  label: string;
+  type: "app" | "addon";
+  deleted: boolean;
+}
+
+const RANGES = ["1h", "6h", "24h", "7d", "14d", "30d"];
+
+export function registerMetrics(program: Command) {
+  program
+    .command("metrics")
+    .description("Show resource metrics (CPU, memory, network, disk) and cost")
+    .option("-s, --service <id>", "Service name or ID (defaults to linked service)")
+    .option("-p, --project <id>", "Project name, slug, or ID")
+    .option("-r, --range <range>", `Time range: ${RANGES.join("|")}`, "1h")
+    .option("-w, --watch", "Live view, refreshed every 3s (Ctrl+C to stop)")
+    .option("--cost", "Show running resources and cost per hour instead of metrics")
+    .action(async (opts) => {
+      if (!RANGES.includes(opts.range)) {
+        error(`Invalid --range "${opts.range}". Choose one of: ${RANGES.join(", ")}`);
+        process.exit(1);
+      }
+      if (opts.watch && isJSONMode()) {
+        error("--watch is interactive and cannot be combined with --json (poll without --watch instead)");
+        process.exit(1);
+      }
+
+      const { projectId, scope } = await resolveProjectScope(opts.project);
+
+      if (opts.cost) {
+        await showCost(projectId, scope);
+        return;
+      }
+
+      // Service detail when -s is given or a service is linked; otherwise
+      // an overview of every service in the project.
+      const hasService = Boolean(opts.service || getProjectLink()?.serviceId);
+
+      if (opts.watch) {
+        let serviceId: string | undefined;
+        if (hasService) {
+          serviceId = (await getActiveServiceWithKind(opts.service, projectId)).id;
+        }
+        await watchLive(projectId, scope, serviceId);
+        return;
+      }
+
+      if (hasService) {
+        await showServiceMetrics(opts.service, projectId, scope, opts.range);
+      } else {
+        await showProjectOverview(projectId, scope);
+      }
+    });
+}
+
+// ── Formatting helpers ────────────────────────────────────────────────────
+
+function fmtBytes(b: number): string {
+  if (!isFinite(b) || b < 0) return "—";
+  if (b < 1024) return `${Math.round(b)} B`;
+  if (b < 1024 * 1024) return `${(b / 1024).toFixed(1)} KB`;
+  if (b < 1024 * 1024 * 1024) return `${(b / 1024 / 1024).toFixed(1)} MB`;
+  return `${(b / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+
+function fmtRate(b: number): string {
+  return `${fmtBytes(b)}/s`;
+}
+
+function fmtMb(mb: number): string {
+  return fmtBytes(mb * 1024 * 1024);
+}
+
+function fmtVcpu(v: number): string {
+  return v.toFixed(2);
+}
+
+/** Render values as a unicode sparkline, downsampled to `width` buckets. */
+function sparkline(values: number[], width = 30): string {
+  if (values.length === 0) return "";
+  const blocks = "▁▂▃▄▅▆▇█";
+  const buckets: number[] = [];
+  const per = Math.max(1, Math.ceil(values.length / width));
+  for (let i = 0; i < values.length; i += per) {
+    const slice = values.slice(i, i + per);
+    buckets.push(slice.reduce((a, b) => a + b, 0) / slice.length);
+  }
+  const max = Math.max(...buckets);
+  if (max <= 0) return chalk.dim(blocks[0].repeat(buckets.length));
+  return buckets
+    .map((v) => blocks[Math.min(blocks.length - 1, Math.floor((v / max) * (blocks.length - 1) + 0.5))])
+    .join("");
+}
+
+function seriesByName(series: SeriesItem[], name: string): number[] {
+  return series.find((s) => s.metric === name)?.values ?? [];
+}
+
+interface MetricStats {
+  now: number | null;
+  min: number;
+  avg: number;
+  max: number;
+  values: number[];
+}
+
+/** min/avg/max over a series. Rate metrics carry an artificial 0 as their
+ *  first sample (no previous counter to diff against) — skip it. */
+function stats(values: number[], isRate = false): MetricStats | null {
+  const vals = isRate && values.length > 1 ? values.slice(1) : values;
+  if (vals.length === 0) return null;
+  return {
+    now: vals[vals.length - 1],
+    min: Math.min(...vals),
+    avg: vals.reduce((a, b) => a + b, 0) / vals.length,
+    max: Math.max(...vals),
+    values: vals,
+  };
+}
+
+// ── Service detail ────────────────────────────────────────────────────────
+
+async function fetchServiceMetrics(
+  svc: { id: string; kind: "app" | "addon" },
+  projectId: string,
+  scope: ResourceScope,
+  range: string,
+): Promise<EntityMetricsResult> {
+  const path =
+    svc.kind === "app"
+      ? withQuery(`/api/apps/${svc.id}/metrics`, { range })
+      : withScope(
+          withQuery(`/api/projects/${projectId}/addons/${svc.id}/metrics`, { range }),
+          scope,
+        );
+  return api.get<EntityMetricsResult>(path);
+}
+
+async function showServiceMetrics(
+  serviceFlag: string | undefined,
+  projectId: string,
+  scope: ResourceScope,
+  range: string,
+) {
+  const svc = await getActiveServiceWithKind(serviceFlag, projectId);
+  const data = await fetchServiceMetrics(svc, projectId, scope, range);
+
+  if (isJSONMode()) {
+    printJSON({ service: { id: svc.id, name: svc.name, kind: svc.kind }, range, ...data });
+    return;
+  }
+
+  const { series, latest, limits } = data;
+  if (series.length === 0 && !latest) {
+    info(chalk.dim(`No metrics for ${svc.name} yet — the service may be new or stopped.`));
+    return;
+  }
+
+  const sampled = latest ? timeAgo(latest.sampledAt) : chalk.dim("no live data");
+  console.log(chalk.bold(svc.name) + chalk.dim(` (${svc.kind}) — last ${range}, sampled ${sampled}`));
+  console.log();
+
+  const cpu = stats(seriesByName(series, "cpu"));
+  const mem = stats(seriesByName(series, "memory"));
+  const rx = stats(seriesByName(series, "network_rx"), true);
+  const tx = stats(seriesByName(series, "network_tx"), true);
+  const dr = stats(seriesByName(series, "disk_read"), true);
+  const dw = stats(seriesByName(series, "disk_write"), true);
+
+  const rows: string[][] = [];
+  const push = (
+    label: string,
+    s: MetricStats | null,
+    fmt: (v: number) => string,
+    now?: number | null,
+  ) => {
+    if (!s) return;
+    const current = now ?? s.now;
+    rows.push([
+      label,
+      current === null || current === undefined ? chalk.dim("—") : fmt(current),
+      fmt(s.min),
+      fmt(s.avg),
+      fmt(s.max),
+      chalk.cyan(sparkline(s.values)),
+    ]);
+  };
+
+  // "Now" for CPU/memory prefers the live Redis snapshot over the last
+  // (up to 90s stale) historical sample.
+  push("CPU (vCPU)", cpu, fmtVcpu, latest ? latest.cpu : undefined);
+  push("Memory", mem, fmtBytes, latest ? latest.memUsedMb * 1024 * 1024 : undefined);
+  push("Net ↓", rx, fmtRate);
+  push("Net ↑", tx, fmtRate);
+  push("Disk read", dr, fmtRate);
+  push("Disk write", dw, fmtRate);
+
+  if (rows.length > 0) {
+    table(["Metric", "Now", "Min", "Avg", "Max", "Trend"], rows);
+  } else if (latest) {
+    // Live snapshot only (brand-new VM, no history rows yet)
+    table(
+      ["Metric", "Now"],
+      [
+        ["CPU (vCPU)", fmtVcpu(latest.cpu)],
+        ["Memory", `${fmtMb(latest.memUsedMb)} / ${fmtMb(latest.memTotalMb)}`],
+      ],
+    );
+  }
+
+  console.log();
+  const diskUsed = seriesByName(series, "disk_used");
+  const diskTotal = seriesByName(series, "disk_total");
+  if (diskUsed.length > 0) {
+    const used = diskUsed[diskUsed.length - 1];
+    const total = diskTotal[diskTotal.length - 1] ?? 0;
+    console.log(
+      chalk.dim("Disk used  ") + fmtBytes(used) + (total > 0 ? chalk.dim(` / ${fmtBytes(total)}`) : ""),
+    );
+  }
+  console.log(
+    chalk.dim("Limits     ") +
+      `${(limits.cpuMillis / 1000).toFixed(limits.cpuMillis % 1000 === 0 ? 0 : 1)} vCPU · ${fmtMb(limits.memoryMi)} memory`,
+  );
+}
+
+// ── Project overview ──────────────────────────────────────────────────────
+
+async function fetchLive(projectId: string, scope: ResourceScope): Promise<ProjectEntityMetrics[]> {
+  const data = await api.get<{ services: ProjectEntityMetrics[] }>(
+    withScope(withQuery(`/api/projects/${projectId}/metrics`, { live: true }), scope),
+  );
+  return (data.services || []).filter((s) => !s.deleted);
+}
+
+function overviewRows(services: ProjectEntityMetrics[]): string[][] {
+  return services.map((s) => {
+    const cpuLimit = s.limits.cpuMillis / 1000;
+    return [
+      s.label,
+      s.type,
+      s.latest ? `${fmtVcpu(s.latest.cpu)} / ${cpuLimit}` : chalk.dim("—"),
+      s.latest ? `${fmtMb(s.latest.memUsedMb)} / ${fmtMb(s.latest.memTotalMb)}` : chalk.dim("—"),
+      s.latest ? timeAgo(s.latest.sampledAt) : chalk.dim("no data"),
+    ];
+  });
+}
+
+async function showProjectOverview(projectId: string, scope: ResourceScope) {
+  const services = await fetchLive(projectId, scope);
+
+  if (isJSONMode()) {
+    printJSON({ services });
+    return;
+  }
+
+  if (services.length === 0) {
+    console.log("No services. Use `lizard add` or `lizard up`.");
+    return;
+  }
+
+  table(["Service", "Type", "CPU (vCPU)", "Memory", "Sampled"], overviewRows(services));
+  info(chalk.dim("\nDetails: lizard metrics -s <service>   Live: lizard metrics --watch"));
+}
+
+// ── Watch mode ────────────────────────────────────────────────────────────
+
+async function watchLive(projectId: string, scope: ResourceScope, serviceId?: string) {
+  info(chalk.dim("Watching metrics... (Ctrl+C to stop)"));
+  // Capture console output so each refresh replaces the previous frame
+  // instead of scrolling.
+  for (;;) {
+    let services: ProjectEntityMetrics[];
+    try {
+      services = await fetchLive(projectId, scope);
+    } catch (e: any) {
+      error(e.message || String(e));
+      process.exit(1);
+    }
+    if (serviceId) services = services.filter((s) => s.id === serviceId);
+
+    process.stdout.write("\x1b[2J\x1b[H"); // clear screen, cursor home
+    console.log(chalk.dim(new Date().toLocaleTimeString()) + chalk.dim("  (refreshes every 3s, Ctrl+C to stop)"));
+    console.log();
+    if (services.length === 0) {
+      console.log(chalk.dim("No services."));
+    } else {
+      table(["Service", "Type", "CPU (vCPU)", "Memory", "Sampled"], overviewRows(services));
+    }
+
+    await new Promise((r) => setTimeout(r, 3000));
+  }
+}
+
+// ── Cost ──────────────────────────────────────────────────────────────────
+
+interface BillingResource {
+  projectId: string;
+  type: "app" | "addon";
+  name: string;
+  addonType?: string;
+  vcpu: number;
+  memoryGb: number;
+  storageGb: number;
+  costPerHour: number;
+}
+
+async function showCost(projectId: string, scope: ResourceScope) {
+  if (!scope.workspaceId) {
+    error("Could not resolve the workspace for this project. Run `lizard link` first.");
+    process.exit(1);
+  }
+
+  let data: { resources: BillingResource[]; costPerHour: number };
+  try {
+    data = await api.get(withQuery("/api/billing/live", { workspaceId: scope.workspaceId }));
+  } catch (e) {
+    if (e instanceof APIError && e.status === 403) {
+      error("Billing is only visible to the workspace owner.");
+      process.exit(2);
+    }
+    throw e;
+  }
+
+  const mine = data.resources.filter((r) => r.projectId === projectId);
+  const projectCost = mine.reduce((a, r) => a + r.costPerHour, 0);
+
+  if (isJSONMode()) {
+    printJSON({
+      projectId,
+      resources: mine,
+      projectCostPerHour: projectCost,
+      workspaceCostPerHour: data.costPerHour,
+    });
+    return;
+  }
+
+  if (mine.length === 0) {
+    console.log("No running resources in this project.");
+  } else {
+    table(
+      ["Resource", "Type", "vCPU", "Memory", "Storage", "$/hr"],
+      mine.map((r) => [
+        r.name,
+        r.addonType ? `addon (${r.addonType})` : r.type,
+        fmtVcpu(r.vcpu),
+        `${r.memoryGb.toFixed(2)} GB`,
+        r.storageGb > 0 ? `${r.storageGb} GB` : chalk.dim("—"),
+        `$${r.costPerHour.toFixed(4)}`,
+      ]),
+    );
+    console.log();
+    console.log(
+      chalk.dim("Project   ") +
+        `$${projectCost.toFixed(4)}/hr` +
+        chalk.dim(` (~$${(projectCost * 730).toFixed(2)}/mo at current usage)`),
+    );
+  }
+  console.log(chalk.dim("Workspace ") + `$${data.costPerHour.toFixed(4)}/hr`);
+}

package/src/index.ts

@@ -27,12 +27,14 @@ import { registerAdd } from "./commands/add.js";
 import { registerConfig } from "./commands/config.js";
 import { registerDocs } from "./commands/docs.js";
 import { registerDomain } from "./commands/domain.js";
+import { registerEvents } from "./commands/events.js";
 import { registerGit } from "./commands/git.js";
 import { registerInit } from "./commands/init.js";
 import { registerLink } from "./commands/link.js";
 import { registerLogin } from "./commands/login.js";
 import { registerLogout } from "./commands/logout.js";
 import { registerLogs } from "./commands/logs.js";
+import { registerMetrics } from "./commands/metrics.js";
 import { registerOpen } from "./commands/open.js";
 import { registerPort } from "./commands/port.js";
 import { registerProjects } from "./commands/projects.js";
@@ -108,12 +110,14 @@ registerAdd(program);
 registerConfig(program);
 registerDocs(program);
 registerDomain(program);
+registerEvents(program);
 registerGit(program);
 registerInit(program);
 registerLink(program);
 registerLogin(program);
 registerLogout(program);
 registerLogs(program);
+registerMetrics(program);
 registerOpen(program);
 registerPort(program);
 registerProjects(program);

package/src/lib/api.ts

@@ -129,90 +129,178 @@ export const api = {
   delete: <T = any>(path: string) => request<T>("DELETE", path),
 };
 
-/** Stream SSE and call handler for each data line. Return false to stop.
+/** Compare two Redis-stream-style event ids (`<ms>-<seq>`). Returns true when
+ *  `id` is at or before `last` — i.e. a replayed event we've already shown.
+ *  Ids in any other format never count as replays. */
+function isReplayedId(id: string, last: string): boolean {
+  const a = id.split("-").map(Number);
+  const b = last.split("-").map(Number);
+  if (a.length !== 2 || b.length !== 2 || a.some(Number.isNaN) || b.some(Number.isNaN)) {
+    return false;
+  }
+  return a[0] < b[0] || (a[0] === b[0] && a[1] <= b[1]);
+}
+
+const MAX_RECONNECT_ATTEMPTS = 5;
+
+/** Stream SSE and call handler for each event. Return false to stop.
  *
  *  `opts.idleTimeoutMs` — stop (resolve) when no *event* arrives for that
  *  long. Heartbeat comments don't reset the timer. Used by `--tail`-style
- *  snapshot reads that must not follow a live stream forever. */
+ *  snapshot reads that must not follow a live stream forever.
+ *
+ *  `opts.reconnect` — re-establish the connection when the server drops it
+ *  (API deploys, proxy idle timeouts). Resumes via `Last-Event-ID` and
+ *  suppresses events the server replays from before the drop. Rejects after
+ *  MAX_RECONNECT_ATTEMPTS consecutive failures so callers exit non-zero
+ *  instead of pretending the stream ended cleanly. `opts.onReconnect` fires
+ *  before each attempt. */
 export function streamSSE(
   path: string,
   handler: (event: string, data: string) => boolean | void,
-  opts: { idleTimeoutMs?: number } = {},
+  opts: {
+    idleTimeoutMs?: number;
+    reconnect?: boolean;
+    onReconnect?: (attempt: number) => void;
+    /** Base backoff between reconnect attempts; scaled by attempt number. */
+    reconnectBaseDelayMs?: number;
+  } = {},
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     const url = new URL(baseURL + path);
     const token = _accessToken || getToken();
-    const reqHeaders: Record<string, string> = {
-      "User-Agent": USER_AGENT,
-      Accept: "text/event-stream",
+    const transport = url.protocol === "https:" ? https : http;
+
+    let finished = false;
+    let attempts = 0;
+    let lastEventId: string | undefined;
+    // Id of the last event handed to the handler — replay marker across reconnects.
+    let lastDispatchedId: string | undefined;
+
+    const settle = (err?: unknown) => {
+      if (finished) return;
+      finished = true;
+      if (err) reject(err);
+      else resolve();
     };
-    if (token) reqHeaders["Authorization"] = `Bearer ${token}`;
 
-    const transport = url.protocol === "https:" ? https : http;
-    const req = transport.request(
-      { hostname: url.hostname, port: url.port || (url.protocol === "https:" ? 443 : 80),
-        path: url.pathname + url.search, method: "GET", headers: reqHeaders },
-      (res) => {
-        if (res.statusCode && res.statusCode >= 400) {
-          let body = "";
-          res.on("data", (c: Buffer) => body += c.toString());
-          res.on("end", () => reject(new APIError(res.statusCode!, `SSE failed: ${body}`)));
-          return;
-        }
-
-        let idleTimer: NodeJS.Timeout | undefined;
-        const finish = () => {
-          if (idleTimer) clearTimeout(idleTimer);
-          req.destroy();
-          resolve();
-        };
-        const armIdleTimer = () => {
-          if (!opts.idleTimeoutMs) return;
-          if (idleTimer) clearTimeout(idleTimer);
-          idleTimer = setTimeout(finish, opts.idleTimeoutMs);
-        };
-        armIdleTimer();
-
-        let buffer = "";
-        let currentEvent = "";
-        let currentData = "";
-
-        res.setEncoding("utf8");
-        res.on("data", (chunk: string) => {
-          buffer += chunk;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-
-          for (const line of lines) {
-            const trimmed = line.replace(/\r$/, "");
-            if (trimmed === "") {
-              if (currentData) {
-                armIdleTimer();
-                const cont = handler(currentEvent, currentData);
-                if (cont === false) {
-                  finish();
-                  return;
+    // Connection dropped without the handler asking to stop.
+    const dropped = (err?: unknown) => {
+      if (finished) return;
+      if (!opts.reconnect) {
+        settle(err);
+        return;
+      }
+      attempts++;
+      if (attempts > MAX_RECONNECT_ATTEMPTS) {
+        settle(
+          err instanceof Error
+            ? err
+            : new Error("SSE stream disconnected and reconnect attempts failed"),
+        );
+        return;
+      }
+      opts.onReconnect?.(attempts);
+      const base = opts.reconnectBaseDelayMs ?? 1000;
+      setTimeout(connect, Math.min(base * attempts, base * 5));
+    };
+
+    const connect = () => {
+      if (finished) return;
+      const reqHeaders: Record<string, string> = {
+        "User-Agent": USER_AGENT,
+        Accept: "text/event-stream",
+      };
+      if (token) reqHeaders["Authorization"] = `Bearer ${token}`;
+      if (lastEventId) reqHeaders["Last-Event-ID"] = lastEventId;
+
+      const req = transport.request(
+        { hostname: url.hostname, port: url.port || (url.protocol === "https:" ? 443 : 80),
+          path: url.pathname + url.search, method: "GET", headers: reqHeaders },
+        (res) => {
+          if (res.statusCode && res.statusCode >= 400) {
+            let body = "";
+            res.on("data", (c: Buffer) => body += c.toString());
+            res.on("end", () => settle(new APIError(res.statusCode!, `SSE failed: ${body}`)));
+            return;
+          }
+
+          let idleTimer: NodeJS.Timeout | undefined;
+          const finish = () => {
+            if (idleTimer) clearTimeout(idleTimer);
+            finished = true;
+            req.destroy();
+            resolve();
+          };
+          const armIdleTimer = () => {
+            if (!opts.idleTimeoutMs) return;
+            if (idleTimer) clearTimeout(idleTimer);
+            idleTimer = setTimeout(finish, opts.idleTimeoutMs);
+          };
+          armIdleTimer();
+
+          let buffer = "";
+          let currentEvent = "";
+          let currentId: string | undefined;
+          let dataLines: string[] = [];
+
+          res.setEncoding("utf8");
+          res.on("data", (chunk: string) => {
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+
+            for (const line of lines) {
+              const trimmed = line.replace(/\r$/, "");
+              if (trimmed === "") {
+                const data = dataLines.join("\n");
+                if (data) {
+                  attempts = 0; // stream is healthy — reset the reconnect budget
+                  armIdleTimer();
+                  // After a reconnect the app-log endpoint replays recent
+                  // history; skip entries we already printed.
+                  const replay =
+                    opts.reconnect && currentId && lastDispatchedId
+                      ? isReplayedId(currentId, lastDispatchedId)
+                      : false;
+                  if (!replay) {
+                    if (currentId) lastDispatchedId = currentId;
+                    const cont = handler(currentEvent, data);
+                    if (cont === false) {
+                      finish();
+                      return;
+                    }
+                  }
                 }
+                currentEvent = "";
+                currentId = undefined;
+                dataLines = [];
+              } else if (trimmed.startsWith("event:")) {
+                currentEvent = trimmed.slice(6).trim();
+              } else if (trimmed.startsWith("data:")) {
+                dataLines.push(trimmed.slice(5).trimStart());
+              } else if (trimmed.startsWith("id:")) {
+                currentId = trimmed.slice(3).trim();
+                lastEventId = currentId;
               }
-              currentEvent = "";
-              currentData = "";
-            } else if (trimmed.startsWith("event:")) {
-              currentEvent = trimmed.slice(6).trim();
-            } else if (trimmed.startsWith("data:")) {
-              currentData = trimmed.slice(5).trimStart();
             }
-          }
-        });
-
-        res.on("end", () => {
-          if (idleTimer) clearTimeout(idleTimer);
-          resolve();
-        });
-        res.on("error", reject);
-      },
-    );
-
-    req.on("error", reject);
-    req.end();
+          });
+
+          res.on("end", () => {
+            if (idleTimer) clearTimeout(idleTimer);
+            dropped();
+          });
+          res.on("error", (err) => {
+            if (idleTimer) clearTimeout(idleTimer);
+            dropped(err);
+          });
+        },
+      );
+
+      req.on("error", dropped);
+      req.end();
+    };
+
+    connect();
   });
 }

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "0.3.42";
+export const CURRENT_VERSION = "0.3.44";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";