@sreetej510/pi-usage 0.1.1 → 0.1.4

package/src/format.ts

@@ -1,208 +0,0 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { BAR_SEGMENTS, LIMIT_VALUE_COLUMN, RESET_FOREGROUND } from "./constants.js";
-import { isOpenAICodexModel, reportMatchesModel } from "./models.js";
-import type {
-  CodexUsageReport,
-  NormalizedCredits,
-  NormalizedRateLimitSnapshot,
-  NormalizedRateLimitWindow,
-  PiModel,
-  ProviderUsageModel,
-  UsageQueryError,
-  UsageReport,
-} from "./types.js";
-import {
-  addNormalizedUsageKey,
-  clampPercent,
-  compactLimitLabel,
-  formatNumber,
-  normalizedKeyHasToken,
-  normalizedUsageKey,
-} from "./utils.js";
-
-export function formatCodexUsageReport(report: CodexUsageReport, _cacheAgeMs?: number): string {
-  const lines = ["  >_ OpenAI Codex Usage", ""];
-
-  for (const snapshot of report.snapshots) {
-    const label = snapshot.limitName ?? snapshot.limitId;
-    if (!isPrimaryCodexSnapshot(snapshot)) {
-      lines.push(`  ${label} limit:`);
-    }
-    if (snapshot.primary) lines.push(formatWindowLine("5h limit:", snapshot.primary));
-    if (snapshot.secondary) lines.push(formatWindowLine("Weekly limit:", snapshot.secondary));
-    if (!snapshot.primary && !snapshot.secondary) {
-      lines.push("  Limits unavailable for this account");
-    }
-  }
-
-  if (report.bankedResetsAvailable !== undefined) {
-    lines.push("");
-    lines.push(`  Banked resets available: ${report.bankedResetsAvailable}`);
-  }
-
-  return lines.join("\n");
-}
-
-export function formatCodexUsageStatusline(report: CodexUsageReport, model?: ProviderUsageModel): string {
-  const snapshot = selectSnapshotForUsageModel(report, model);
-  if (!snapshot) return "usage unavailable";
-
-  const parts = [formatStatuslinePrefix(snapshot)];
-  if (snapshot.primary) parts.push(`${clampPercent(snapshot.primary.usedPercent).toFixed(0)}% 5h`);
-  if (snapshot.secondary) parts.push(`${clampPercent(snapshot.secondary.usedPercent).toFixed(0)}% wk`);
-  if (parts.length === 1 && snapshot.credits) parts.push(formatCredits(snapshot.credits));
-  return parts.join(" ");
-}
-
-export function formatUsageStatusline(report: UsageReport, model?: ProviderUsageModel): string {
-  return report.provider === "anthropic" ? report.statusline : formatCodexUsageStatusline(report, model);
-}
-
-export function formatUsageReport(report: UsageReport, cacheAgeMs?: number): string {
-  return report.provider === "anthropic" ? report.summaryLines.join("\n") : formatCodexUsageReport(report, cacheAgeMs);
-}
-
-export function showReport(ctx: ExtensionCommandContext, report: UsageReport, fromCache: boolean): void {
-  const text = formatUsageReport(report, fromCache ? Date.now() - report.capturedAt : undefined);
-  ctx.ui.notify(ctx.hasUI ? brightenInfoNotification(text) : text, "info");
-}
-
-export function showReports(ctx: ExtensionCommandContext, reports: UsageReport[], fromCache: boolean): void {
-  const ordered = orderReportsForCurrentProvider(reports, ctx.model);
-  const text = ordered
-    .map((report) => formatUsageReport(report, fromCache ? Date.now() - report.capturedAt : undefined))
-    .join("\n\n");
-  ctx.ui.notify(ctx.hasUI ? brightenInfoNotification(text) : text, "info");
-}
-
-export function formatQueryErrors(errors: UsageQueryError[]): string {
-  const lines = ["Unable to read usage for the current provider."];
-  for (const error of errors) {
-    const source =
-      error.source === "pi-auth"
-        ? "Pi Codex auth"
-        : error.source === "codex-app-server"
-          ? "Codex app-server fallback"
-          : "Anthropic OAuth usage";
-    lines.push(`- ${source}: ${error.message}`);
-  }
-  lines.push("");
-  lines.push(
-    "Tip: use a Pi OpenAI Codex model or Pi Anthropic model. For Codex, /login with OpenAI ChatGPT Plus/Pro. For Anthropic, /login with Anthropic so the OAuth usage endpoint can be queried.",
-  );
-  return lines.join("\n");
-}
-
-export function progressBarUsed(percentUsed: number): string {
-  const filled = Math.round((clampPercent(percentUsed) / 100) * BAR_SEGMENTS);
-  return `[${"█".repeat(filled)}${"░".repeat(BAR_SEGMENTS - filled)}]`;
-}
-
-function selectSnapshotForUsageModel(
-  report: CodexUsageReport,
-  model: ProviderUsageModel | undefined,
-): NormalizedRateLimitSnapshot | undefined {
-  const codexSnapshot = report.snapshots.find(isPrimaryCodexSnapshot);
-  if (!model || !isOpenAICodexModel(model)) return codexSnapshot ?? report.snapshots[0];
-
-  const modelKeys = normalizedModelUsageKeys(model);
-  const exactMatch = report.snapshots.find((snapshot) =>
-    normalizedSnapshotUsageKeys(snapshot).some((key) => modelKeys.has(key)),
-  );
-  if (exactMatch) return exactMatch;
-
-  const variants = codexModelVariantKeys(modelKeys);
-  for (const variant of variants) {
-    const matches = report.snapshots.filter(
-      (snapshot) =>
-        !isPrimaryCodexSnapshot(snapshot) &&
-        normalizedSnapshotUsageKeys(snapshot).some((key) => normalizedKeyHasToken(key, variant)),
-    );
-    if (matches.length === 1) return matches[0];
-  }
-
-  return codexSnapshot ?? report.snapshots[0];
-}
-
-function normalizedModelUsageKeys(model: ProviderUsageModel): Set<string> {
-  const keys = new Set<string>();
-  addNormalizedUsageKey(keys, model.id);
-  addNormalizedUsageKey(keys, model.name);
-
-  for (const key of [...keys]) {
-    const codexIndex = key.indexOf("codex");
-    if (codexIndex >= 0) keys.add(key.slice(codexIndex));
-  }
-
-  return keys;
-}
-
-function normalizedSnapshotUsageKeys(snapshot: NormalizedRateLimitSnapshot): string[] {
-  return [normalizedUsageKey(snapshot.limitId), normalizedUsageKey(snapshot.limitName)].filter(
-    (key): key is string => key !== undefined,
-  );
-}
-
-function codexModelVariantKeys(modelKeys: Set<string>): string[] {
-  const variants = new Set<string>();
-  for (const key of modelKeys) {
-    const match = key.match(/(?:^|-)codex-(.+)$/);
-    if (match?.[1]) variants.add(match[1]);
-  }
-  return [...variants];
-}
-
-function formatStatuslinePrefix(snapshot: NormalizedRateLimitSnapshot): string {
-  if (isPrimaryCodexSnapshot(snapshot)) return "codex";
-  const label = snapshot.limitName ?? snapshot.limitId;
-  return `codex ${compactLimitLabel(label)}`;
-}
-
-function orderReportsForCurrentProvider(
-  reports: UsageReport[],
-  model: Pick<PiModel, "provider"> | undefined,
-): UsageReport[] {
-  return [...reports].sort((left, right) => {
-    const leftCurrent = reportMatchesModel(left, model) ? 0 : 1;
-    const rightCurrent = reportMatchesModel(right, model) ? 0 : 1;
-    return leftCurrent - rightCurrent;
-  });
-}
-
-function brightenInfoNotification(text: string): string {
-  return `${RESET_FOREGROUND}${text}`;
-}
-
-function isPrimaryCodexSnapshot(snapshot: NormalizedRateLimitSnapshot): boolean {
-  return normalizedUsageKey(snapshot.limitId) === "codex" || normalizedUsageKey(snapshot.limitName) === "codex";
-}
-
-function formatWindowLine(label: string, window: NormalizedRateLimitWindow): string {
-  return `  ${label.padEnd(LIMIT_VALUE_COLUMN)}${formatWindow(window)}`;
-}
-
-function formatWindow(window: NormalizedRateLimitWindow): string {
-  const used = clampPercent(window.usedPercent);
-  const reset = window.resetsAt ? ` (resets ${formatReset(window.resetsAt)})` : "";
-  return `${progressBarUsed(used)} ${used.toFixed(0)}% used${reset}`;
-}
-
-function formatCredits(credits: NormalizedCredits): string {
-  if (!credits.hasCredits) return "no credits";
-  if (credits.unlimited) return "unlimited credits";
-  const balance = credits.balance?.trim();
-  if (!balance) return "credits available";
-  return `${formatNumber(Number(balance), balance)} credits`;
-}
-
-function formatReset(epochSeconds: number): string {
-  const reset = new Date(epochSeconds * 1000);
-  if (Number.isNaN(reset.getTime())) return "at an unknown time";
-
-  const now = new Date();
-  const time = `${reset.getHours().toString().padStart(2, "0")}:${reset.getMinutes().toString().padStart(2, "0")}`;
-  if (reset.toDateString() === now.toDateString()) return time;
-  const day = reset.getDate().toString();
-  const month = reset.toLocaleDateString(undefined, { month: "short" });
-  return `${time} on ${day} ${month}`;
-}

package/src/http.ts

@@ -1,21 +0,0 @@
-import { errorMessage } from "./utils.js";
-
-export async function fetchWithTimeout(
-  url: string,
-  init: RequestInit,
-  timeoutMs: number,
-  label = "usage",
-): Promise<Response> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { ...init, signal: controller.signal });
-  } catch (error) {
-    if (controller.signal.aborted) {
-      throw new Error(`Timed out after ${Math.round(timeoutMs / 1000)}s while fetching ${label}.`);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/index.ts

@@ -1,100 +0,0 @@
-/**
- * Pi Usage Extension
- *
- * Reports provider usage and rate-limit budgets for OpenAI Codex and Anthropic
- * OAuth subscriptions via /usage, with an optional statusline widget and custom
- * footer that right-aligns usage status.
- *
- * File layout:
- *   index.ts              extension entry point (this file) — commands + lifecycle events
- *   constants.ts          command name, URLs, timeouts, cache paths, UI constants
- *   types.ts              shared TypeScript types (public types exported)
- *   args.ts               /usage argument completions and parsing
- *   utils.ts              small helpers (asString, parseJsonObject, delay, etc.)
- *   errors.ts             UsageEndpointError, stale-context detection, rate-limit backoff
- *   http.ts               fetchWithTimeout
- *   models.ts             provider/model matching and auth candidate enumeration
- *   shared-cache.ts       on-disk shared usage cache read/write across pi sessions
- *   codex-auth.ts         resolve Pi Codex auth headers (+ WHAM + account id)
- *   codex-reset-credits.ts fetch/consume/format Codex banked resets
- *   codex-app-server.ts   CodexAppServerClient + queryViaCodexAppServer fallback
- *   normalize-codex.ts    normalize backend + app-server Codex rate-limit payloads
- *   normalize-anthropic.ts normalize Anthropic OAuth usage payloads
- *   codex-query.ts        queryViaPiAuth + queryCodexUsageWithFallback
- *   anthropic-auth.ts     resolve Pi Anthropic OAuth auth headers
- *   anthropic-query.ts    queryAnthropicUsage + fetchRawUsagePayloads (--raw)
- *   query.ts              queryUsage, queryAllUsage, queryUsageWithRetries
- *   format.ts             usage report/statusline formatting and display notifications
- *   footer.ts             custom footer with right-aligned usage status
- *   statusline.ts         statusline state, timers, and background refresh
- *   command.ts            /usage command handler
- */
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { registerUsageCommand } from "./command.js";
-import { installUsageFooter, isFooterRegistered, setFooterRegistered } from "./footer.js";
-import { isUsageSupportedModel } from "./models.js";
-import {
-  clearUsageStatusline,
-  handleStaleContextError,
-  refreshCurrentUsageStatusline,
-  rethrowUnlessStaleContextError,
-  setSessionActive,
-} from "./statusline.js";
-
-export { completeCodexStatusArguments, parseArgs } from "./args.js";
-export { isStaleExtensionContextError } from "./errors.js";
-export { formatCodexUsageReport, formatCodexUsageStatusline } from "./format.js";
-export { normalizeAppServerResponse, normalizeBackendPayload } from "./normalize-codex.js";
-export type {
-  AnthropicUsageReport,
-  CodexUsageReport,
-  NormalizedCredits,
-  NormalizedRateLimitSnapshot,
-  NormalizedRateLimitWindow,
-  ProviderUsageModel,
-} from "./types.js";
-
-export default function usageExtension(pi: ExtensionAPI) {
-  registerUsageCommand(pi);
-
-  const ensureUsageFooter = (ctx: ExtensionContext) => {
-    if (isFooterRegistered() || !ctx.hasUI) return;
-    try {
-      installUsageFooter(pi, ctx);
-      setFooterRegistered(true);
-    } catch (error) {
-      if (!handleStaleContextError(ctx, error)) throw error;
-    }
-  };
-
-  pi.on("session_start", (_event, ctx) => {
-    setSessionActive(true);
-    ensureUsageFooter(ctx);
-    if (isUsageSupportedModel(ctx.model)) {
-      void refreshCurrentUsageStatusline(ctx, ctx.model).catch(rethrowUnlessStaleContextError(ctx));
-    } else {
-      clearUsageStatusline(ctx);
-    }
-  });
-
-  pi.on("session_tree", (_event, ctx) => {
-    if (isUsageSupportedModel(ctx.model)) {
-      void refreshCurrentUsageStatusline(ctx, ctx.model).catch(rethrowUnlessStaleContextError(ctx));
-    } else {
-      clearUsageStatusline(ctx);
-    }
-  });
-
-  pi.on("model_select", (event, ctx) => {
-    if (isUsageSupportedModel(event.model)) {
-      void refreshCurrentUsageStatusline(ctx, event.model).catch(rethrowUnlessStaleContextError(ctx));
-    } else {
-      clearUsageStatusline(ctx);
-    }
-  });
-
-  pi.on("session_shutdown", (_event, ctx) => {
-    setSessionActive(false);
-    clearUsageStatusline(ctx);
-  });
-}

package/src/models.ts

@@ -1,73 +0,0 @@
-import { ANTHROPIC_PROVIDER_ID, CODEX_PROVIDER_ID } from "./constants.js";
-import type { PiModel, UsageReport } from "./types.js";
-
-export function isOpenAICodexModel(model: Pick<PiModel, "provider"> | undefined): boolean {
-  return model?.provider === CODEX_PROVIDER_ID;
-}
-
-export function isAnthropicModel(model: Pick<PiModel, "provider"> | undefined): boolean {
-  return model?.provider === ANTHROPIC_PROVIDER_ID;
-}
-
-export function isUsageSupportedModel(model: Pick<PiModel, "provider"> | undefined): boolean {
-  return isOpenAICodexModel(model) || isAnthropicModel(model);
-}
-
-export function reportMatchesModel(report: UsageReport, model: Pick<PiModel, "provider"> | undefined): boolean {
-  if (!model) return false;
-  return (
-    (report.provider === "codex" && isOpenAICodexModel(model)) ||
-    (report.provider === "anthropic" && isAnthropicModel(model))
-  );
-}
-
-export function providerKeyForModel(model: Pick<PiModel, "provider"> | undefined): "codex" | "anthropic" {
-  if (isAnthropicModel(model)) return "anthropic";
-  return "codex";
-}
-
-export function codexAuthCandidateModels(ctx: {
-  model?: PiModel;
-  modelRegistry: {
-    getAvailable: () => PiModel[];
-    getAll: () => PiModel[];
-  };
-}): PiModel[] {
-  return providerAuthCandidateModels(ctx, CODEX_PROVIDER_ID);
-}
-
-export function anthropicAuthCandidateModels(ctx: {
-  model?: PiModel;
-  modelRegistry: {
-    getAvailable: () => PiModel[];
-    getAll: () => PiModel[];
-  };
-}): PiModel[] {
-  return providerAuthCandidateModels(ctx, ANTHROPIC_PROVIDER_ID);
-}
-
-function providerAuthCandidateModels(
-  ctx: {
-    model?: PiModel;
-    modelRegistry: {
-      getAvailable: () => PiModel[];
-      getAll: () => PiModel[];
-    };
-  },
-  providerId: string,
-): PiModel[] {
-  const candidates: PiModel[] = [];
-  const seen = new Set<string>();
-  const add = (model: PiModel | undefined) => {
-    if (!model || model.provider !== providerId) return;
-    const key = `${model.provider}/${model.id}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    candidates.push(model);
-  };
-
-  add(ctx.model);
-  for (const model of ctx.modelRegistry.getAvailable()) add(model);
-  for (const model of ctx.modelRegistry.getAll()) add(model);
-  return candidates;
-}

package/src/normalize-anthropic.ts

@@ -1,160 +0,0 @@
-import { ANTHROPIC_NON_WINDOW_KEYS } from "./constants.js";
-import { progressBarUsed } from "./format.js";
-import type {
-  AnthropicExtraUsage,
-  AnthropicOAuthUsagePayload,
-  AnthropicOAuthWindow,
-  AnthropicUsageReport,
-} from "./types.js";
-import {
-  asBoolean,
-  asNumber,
-  asString,
-  assertObject,
-  clampPercent,
-  compactLimitLabel,
-  formatCurrencyAmount,
-} from "./utils.js";
-
-export function normalizeAnthropicUsagePayload(
-  payload: AnthropicOAuthUsagePayload,
-  capturedAt: number,
-): AnthropicUsageReport {
-  const lines = ["  >_ Anthropic Usage", ""];
-  const statusParts: string[] = ["claude"];
-
-  const enterpriseWindows: {
-    key: string;
-    usedPercent: number;
-    usedDollars: number;
-    limitDollars: number;
-    resetsAt?: string;
-  }[] = [];
-  for (const [key, rawValue] of Object.entries(payload)) {
-    if (ANTHROPIC_NON_WINDOW_KEYS.has(key)) continue;
-    if (!rawValue || typeof rawValue !== "object" || Array.isArray(rawValue)) continue;
-    const value = rawValue as AnthropicOAuthWindow;
-    const limitDollars = asNumber(value.limit_dollars);
-    const usedDollars = asNumber(value.used_dollars);
-    if (limitDollars === undefined || usedDollars === undefined) continue;
-    enterpriseWindows.push({
-      key,
-      usedPercent: clampPercent(asNumber(value.utilization) ?? 0),
-      usedDollars,
-      limitDollars,
-      resetsAt: asString(value.resets_at),
-    });
-  }
-
-  let hasAnySection = false;
-
-  // Section 1: enterprise budget windows
-  if (enterpriseWindows.length > 0) {
-    hasAnySection = true;
-    enterpriseWindows.sort((left, right) => left.limitDollars - right.limitDollars);
-    lines.push("  Enterprise budget windows:");
-    for (const window of enterpriseWindows) {
-      const label = compactLimitLabel(window.key).replace(/\b\w/g, (char) => char.toUpperCase());
-      const reset = window.resetsAt ? ` (resets ${formatIsoReset(window.resetsAt)})` : "";
-      lines.push(
-        `  ${label}: ${progressBarUsed(window.usedPercent)} ${window.usedPercent.toFixed(0)}% used (${formatCurrencyAmount(window.usedDollars, "USD")}/${formatCurrencyAmount(window.limitDollars, "USD")})${reset}`,
-      );
-    }
-    // Statusline shows the window that's actually moving: the one with the
-    // highest utilization (not just the smallest limit).
-    const primary = [...enterpriseWindows].sort((left, right) => right.usedPercent - left.usedPercent)[0];
-    statusParts.push(`${primary.usedPercent.toFixed(0)}%`);
-    statusParts.push(
-      `${formatCurrencyAmount(primary.usedDollars, "USD", 0)}/${formatCurrencyAmount(primary.limitDollars, "USD", 0)}`,
-    );
-  }
-
-  // Section 2: monthly extra usage (pay-per-use overflow). Shown alongside
-  // enterprise windows — both are real spend and both belong in the statusline.
-  const extraUsageRaw = payload.extra_usage;
-  if (extraUsageRaw) {
-    const extraUsage = assertObject(extraUsageRaw, "Anthropic extra usage") as AnthropicExtraUsage;
-    const enabled = asBoolean(extraUsage.is_enabled);
-    const usedCredits = asNumber(extraUsage.used_credits);
-    if (enabled && usedCredits !== undefined) {
-      if (hasAnySection) lines.push("");
-      const hadStatusSegment = statusParts.length > 1;
-      hasAnySection = true;
-      const currency = asString(extraUsage.currency) ?? "USD";
-      // used_credits / monthly_limit are minor units (cents): 30000 => 300.00
-      const usedMajor = usedCredits / 100;
-      const monthlyLimitMajor =
-        asNumber(extraUsage.monthly_limit) !== undefined
-          ? (asNumber(extraUsage.monthly_limit) as number) / 100
-          : undefined;
-      const usedPercent = clampPercent(asNumber(extraUsage.utilization) ?? 0);
-      const amount = `${formatCurrencyAmount(usedMajor, currency)}${monthlyLimitMajor !== undefined ? `/${formatCurrencyAmount(monthlyLimitMajor, currency)}` : ""}`;
-      const amountCompact = `${formatCurrencyAmount(usedMajor, currency, 0)}${monthlyLimitMajor !== undefined ? `/${formatCurrencyAmount(monthlyLimitMajor, currency, 0)}` : ""}`;
-      const resetsAt = asString(extraUsage.reset_at) ?? asString(extraUsage.resets_at);
-      const reset = resetsAt ? ` (resets ${formatIsoReset(resetsAt)})` : "";
-      lines.push("  Monthly extra usage:");
-      lines.push(`  ${progressBarUsed(usedPercent)} ${usedPercent.toFixed(0)}% used ${amount}${reset}`);
-      // Append alongside any enterprise-window segment already added — don't
-      // overwrite it. Label with "extra" only when it's not the sole segment,
-      // so accounts with just extra usage keep the simpler unlabeled form.
-      statusParts.push(`${usedPercent.toFixed(0)}%`);
-      statusParts.push(amountCompact);
-      if (hadStatusSegment) statusParts.push("extra");
-    }
-  }
-
-  // Section 3: subscription rolling windows
-  const fiveHour = normalizeAnthropicRollingWindow(payload.five_hour);
-  const sevenDay = normalizeAnthropicRollingWindow(payload.seven_day);
-  if (fiveHour || sevenDay) {
-    if (hasAnySection) lines.push("");
-    hasAnySection = true;
-    lines.push("  Subscription usage:");
-    if (fiveHour) lines.push(`  ${formatAnthropicRollingWindow("5h", fiveHour, false)}`);
-    if (sevenDay) lines.push(`  ${formatAnthropicRollingWindow("7d", sevenDay, true)}`);
-    if (statusParts.length === 1) {
-      if (fiveHour) statusParts.push(`${fiveHour.usedPercent.toFixed(0)}% 5h`);
-      if (sevenDay) statusParts.push(`${sevenDay.usedPercent.toFixed(0)}% 7d`);
-    }
-  }
-
-  if (!hasAnySection) {
-    throw new Error("Anthropic usage endpoint returned no displayable usage data.");
-  }
-
-  return {
-    provider: "anthropic",
-    source: "anthropic-oauth",
-    capturedAt,
-    summaryLines: lines,
-    statusline: statusParts.join(" "),
-  };
-}
-
-function normalizeAnthropicRollingWindow(value: unknown): { usedPercent: number; resetsAt?: string } | undefined {
-  if (!value) return undefined;
-  const window = assertObject(value, "Anthropic rolling usage window") as AnthropicOAuthWindow;
-  const usedPercent = asNumber(window.utilization);
-  if (usedPercent === undefined) return undefined;
-  return { usedPercent: clampPercent(usedPercent), resetsAt: asString(window.resets_at) };
-}
-
-function formatAnthropicRollingWindow(
-  label: string,
-  window: { usedPercent: number; resetsAt?: string },
-  showDay: boolean,
-): string {
-  const reset = window.resetsAt ? ` (resets ${formatIsoReset(window.resetsAt, showDay)})` : "";
-  return `${label}: ${progressBarUsed(window.usedPercent)} ${window.usedPercent.toFixed(0)}% used${reset}`;
-}
-
-function formatIsoReset(value: string, showDay = true): string {
-  const reset = new Date(value);
-  if (Number.isNaN(reset.getTime())) return "at an unknown time";
-  const now = new Date();
-  const time = `${reset.getHours().toString().padStart(2, "0")}:${reset.getMinutes().toString().padStart(2, "0")}`;
-  if (!showDay && reset.toDateString() === now.toDateString()) return time;
-  const day = reset.getDate().toString();
-  const month = reset.toLocaleDateString(undefined, { month: "short" });
-  return `${time} on ${day} ${month}`;
-}