/**
 * Production Error Tools & Browser
 *
 * Fetches and displays production error data from the /api/v1/errors JSON API.
 *
 * Credentials are read from environment variables:
 *   PI_API_TOKEN         — Bearer token for API auth
 *   PI_SERVICE_FQDN_WEB  — Production domain (e.g., https://musiclibrary.example.com)
 *
 * Tools:
 *   fetch_production_errors  — List/filter errors with pagination
 *   fetch_production_error   — Single error detail with occurrences and stacktraces
 *
 * Commands:
 *   /prod-errors  — Interactive TUI for browsing production errors
 */

import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
import {
  truncateTail,
  formatSize,
  DEFAULT_MAX_BYTES,
  DEFAULT_MAX_LINES,
} from "@mariozechner/pi-coding-agent";
import { BorderedLoader } from "@mariozechner/pi-coding-agent";
import { matchesKey, Key, truncateToWidth } from "@mariozechner/pi-tui";
import { Type } from "typebox";

// ── Types ───────────────────────────────────────────────────────────────────

interface ErrorListItem {
  id: number;
  kind: string;
  reason: string;
  source_line: string;
  source_function: string;
  status: string;
  fingerprint: string;
  last_occurrence_at: string;
  muted: boolean;
  inserted_at: string;
  updated_at: string;
}

interface ErrorListResponse {
  errors: ErrorListItem[];
  total: number;
  limit: number;
  offset: number;
}

interface StacktraceLine {
  application: string;
  module: string;
  function: string;
  arity: number;
  file: string;
  line: number;
}

interface Occurrence {
  id: number;
  reason: string;
  context: Record<string, unknown>;
  breadcrumbs: string[];
  stacktrace: { lines: StacktraceLine[] };
  error_id: number;
  inserted_at: string;
}

interface ErrorDetail {
  id: number;
  kind: string;
  reason: string;
  source_line: string;
  source_function: string;
  status: string;
  fingerprint: string;
  last_occurrence_at: string;
  muted: boolean;
  inserted_at: string;
  updated_at: string;
  occurrence_count: number;
  first_occurrence_at: string | null;
  occurrences: Occurrence[];
}

interface ErrorDetailResponse {
  error: ErrorDetail;
}

// ── Helpers ─────────────────────────────────────────────────────────────────

function resolveVar(name: string): string | undefined {
  return process.env[`PI_${name.toUpperCase()}`];
}

function buildUrl(
  base: string,
  path: string,
  params?: Record<string, string>,
): string {
  // Strip trailing slash and ensure protocol.
  // Default to https:// unless the host looks like a local/dev address.
  let url = base.replace(/\/+$/, "");
  if (!/^https?:\/\//i.test(url)) {
    const isLocal =
      url.startsWith("localhost") ||
      url.startsWith("127.") ||
      url.startsWith("0.0.0.0") ||
      url.startsWith("[::1]");
    url = `${isLocal ? "http" : "https"}://${url}`;
  }
  url = `${url}${path}`;

  if (params) {
    const searchParams = new URLSearchParams();
    for (const [key, value] of Object.entries(params)) {
      if (value !== undefined && value !== null) {
        searchParams.set(key, value);
      }
    }
    const qs = searchParams.toString();
    if (qs) {
      url = `${url}?${qs}`;
    }
  }

  return url;
}

// ── Formatting ──────────────────────────────────────────────────────────────

function formatErrorListItem(error: ErrorListItem, index: number): string {
  const mutedLabel = error.muted ? " [MUTED]" : "";
  return [
    `#${index} [${error.status}]${mutedLabel} ${error.kind}: ${error.reason}`,
    `   Source: ${error.source_line} — ${error.source_function}`,
    `   Last occurrence: ${error.last_occurrence_at}`,
    `   Fingerprint: ${error.fingerprint}`,
    `   ID: ${error.id}`,
  ].join("\n");
}

function formatDetailLines(error: ErrorDetail): string[] {
  const lines: string[] = [];
  const sep = "─".repeat(44);

  lines.push(`Error #${error.id}: ${error.kind}`);
  lines.push(sep);
  lines.push(`Reason: ${error.reason}`);
  lines.push(`Status: ${error.status} | Muted: ${error.muted}`);
  lines.push(`Source: ${error.source_line} — ${error.source_function}`);
  lines.push(`Fingerprint: ${error.fingerprint}`);
  lines.push(`First occurrence: ${error.first_occurrence_at ?? "N/A"}`);
  lines.push(`Last occurrence: ${error.last_occurrence_at}`);
  lines.push(`Total occurrences: ${error.occurrence_count}`);
  lines.push(`Created: ${error.inserted_at} | Updated: ${error.updated_at}`);

  const occurrences = error.occurrences ?? [];
  lines.push("");
  lines.push(`Occurrences (${occurrences.length}):`);
  lines.push(sep);

  if (occurrences.length === 0) {
    lines.push("  No occurrences recorded");
  } else {
    for (let i = 0; i < occurrences.length; i++) {
      const occ = occurrences[i]!;
      lines.push(`#${i + 1} ${occ.inserted_at}`);
      lines.push(`   Reason: ${occ.reason}`);

      // Context as key-value pairs
      if (occ.context && Object.keys(occ.context).length > 0) {
        const ctxLines = Object.entries(occ.context).map(
          ([k, v]) => `     ${k}: ${JSON.stringify(v)}`,
        );
        lines.push(`   Context:`);
        lines.push(...ctxLines);
      }

      // Breadcrumbs as bullet list
      if (occ.breadcrumbs && occ.breadcrumbs.length > 0) {
        lines.push(`   Breadcrumbs:`);
        for (const crumb of occ.breadcrumbs) {
          lines.push(`     • ${crumb}`);
        }
      }

      // Stacktrace
      if (occ.stacktrace?.lines && occ.stacktrace.lines.length > 0) {
        lines.push(`   Stacktrace:`);
        for (const sl of occ.stacktrace.lines) {
          const app = sl.application || "—";
          const loc = sl.file
            ? `${sl.file}${sl.line != null ? `:${sl.line}` : ""}`
            : "(nofile)";
          lines.push(
            `     ${app} / ${sl.module}.${sl.function}/${sl.arity}  ${loc}`,
          );
        }
      }

      if (i < occurrences.length - 1) {
        lines.push("");
      }
    }
  }

  return lines;
}

function formatErrorDetail(error: ErrorDetail): string {
  return formatDetailLines(error).join("\n");
}

function applyOutputTruncation(output: string): string {
  const truncation = truncateTail(output, {
    maxLines: DEFAULT_MAX_LINES,
    maxBytes: DEFAULT_MAX_BYTES,
  });

  if (truncation.truncated) {
    return (
      truncation.content +
      `\n\n[Output truncated: ${truncation.outputLines} of ${truncation.totalLines} lines ` +
      `(${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}). ` +
      `Use narrower filters to reduce output.]`
    );
  }

  return truncation.content;
}

// ── HTTP helpers ────────────────────────────────────────────────────────────

async function fetchApi<T>(
  url: string,
  token: string,
  validate: (data: unknown) => T,
  signal?: AbortSignal,
): Promise<T> {
  const response = await fetch(url, {
    headers: { Authorization: `Bearer ${token}` },
    signal,
  });

  if (!response.ok) {
    const body = await response.text().catch(() => "(unable to read body)");
    const truncated = body.length > 500 ? body.slice(0, 500) + "..." : body;
    throw new Error(
      `API returned ${response.status} ${response.statusText}\n${truncated}`,
    );
  }

  let data: unknown;
  try {
    data = await response.json();
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    throw new Error(
      `Failed to parse API response: ${message}. Status: ${response.status}.`,
    );
  }

  return validate(data);
}

async function fetchErrors(
  url: string,
  token: string,
  signal?: AbortSignal,
): Promise<ErrorListResponse> {
  return fetchApi(
    url,
    token,
    (data) => {
      const obj = data as Record<string, unknown>;
      if (!obj.errors || !Array.isArray(obj.errors)) {
        throw new Error(
          `Unexpected API response: 'errors' field is missing or not an array. Got: ${
            obj.errors === null ? "null" : typeof obj.errors
          }.`,
        );
      }
      return data as ErrorListResponse;
    },
    signal,
  );
}

async function fetchError(
  url: string,
  token: string,
  signal?: AbortSignal,
): Promise<ErrorDetailResponse> {
  return fetchApi(
    url,
    token,
    (data) => {
      const obj = data as Record<string, unknown>;
      if (!obj.error || typeof obj.error !== "object") {
        throw new Error(
          `Unexpected API response: 'error' field is missing or not an object. Got: ${
            obj.error === null ? "null" : typeof obj.error
          }.`,
        );
      }
      return data as ErrorDetailResponse;
    },
    signal,
  );
}

async function postApi<T>(
  url: string,
  token: string,
  validate: (data: unknown) => T,
  signal?: AbortSignal,
): Promise<T> {
  const response = await fetch(url, {
    method: "POST",
    headers: { Authorization: `Bearer ${token}` },
    signal,
  });

  if (!response.ok) {
    const body = await response.text().catch(() => "(unable to read body)");
    const truncated = body.length > 500 ? body.slice(0, 500) + "..." : body;
    throw new Error(
      `API returned ${response.status} ${response.statusText}\n${truncated}`,
    );
  }

  let data: unknown;
  try {
    data = await response.json();
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    throw new Error(
      `Failed to parse API response: ${message}. Status: ${response.status}.`,
    );
  }

  return validate(data);
}

// ── TUI Theme ───────────────────────────────────────────────────────────────

/** Minimal theme interface for color application in the ErrorBrowser. */
interface Theme {
  fg(color: string, text: string): string;
  bold(text: string): string;
}

// ── TUI Helpers ─────────────────────────────────────────────────────────────

function formatRelativeTime(iso8601: string): string {
  const then = new Date(iso8601).getTime();
  if (isNaN(then)) return "unknown";

  const now = Date.now();
  const diffSec = Math.floor((now - then) / 1000);

  if (diffSec < 60) return "just now";

  const diffMin = Math.floor(diffSec / 60);
  if (diffMin < 60) return `${diffMin}m ago`;

  const diffHour = Math.floor(diffMin / 60);
  if (diffHour < 24) return `${diffHour}h ago`;

  const diffDay = Math.floor(diffHour / 24);
  return `${diffDay}d ago`;
}

function truncateReason(reason: string, maxLen: number): string {
  // Take only the first line
  const firstLine = reason.split("\n")[0] ?? reason;
  if (firstLine.length <= maxLen) return firstLine;
  return firstLine.slice(0, maxLen - 1) + "…";
}

// ── Error Browser Component ─────────────────────────────────────────────────

class ErrorBrowser {
  // ── State ──────────────────────────────────────────────────────────────

  private mode: "list" | "detail" | "loading" = "list";
  private errors: ErrorListItem[];
  private total: number;
  private offset: number;
  private readonly limit: number = 50;
  private showResolved: boolean = true;
  private showMuted: boolean = true;
  private cursorIndex: number = 0;
  private scrollOffset: number = 0;
  private selectedError: ErrorDetail | null = null;
  private detailScrollOffset: number = 0;
  private readonly totalUnfiltered: number;
  private readonly chromeHeight: number = 7;
  private readonly errorEntryLines: number = 3;

  // ── Callbacks ──────────────────────────────────────────────────────────

  onClose?: () => void;
  onCopy?: (text: string) => void;

  // ── Caching ────────────────────────────────────────────────────────────

  private cachedWidth?: number;
  private cachedLines?: string[];

  // ── HTTP ───────────────────────────────────────────────────────────────

  private currentAbortController?: AbortController;
  private readonly baseUrl: string;
  private readonly token: string;
  private readonly requestRender: () => void;
  private readonly notify: (
    msg: string,
    level: "error" | "info" | "warning",
  ) => void;

  constructor(
    errors: ErrorListItem[],
    total: number,
    baseUrl: string,
    token: string,
    requestRender: () => void,
    notify: (msg: string, level: "error" | "info" | "warning") => void,
  ) {
    this.errors = errors;
    this.total = total;
    this.totalUnfiltered = total;
    this.offset = 0;
    this.baseUrl = baseUrl;
    this.token = token;
    this.requestRender = requestRender;
    this.notify = notify;
    this.clampCursor();
  }

  // ── Viewport ───────────────────────────────────────────────────────────

  private get visibleHeight(): number {
    return Math.max(10, process.stdout.rows - this.chromeHeight);
  }

  // ── Navigation helpers ─────────────────────────────────────────────────

  private clampCursor(): void {
    if (this.errors.length === 0) {
      this.cursorIndex = -1;
    } else {
      this.cursorIndex = Math.max(
        0,
        Math.min(this.cursorIndex, this.errors.length - 1),
      );
    }
  }

  private clampViewport(): void {
    if (this.errors.length === 0) return;
    const maxEntries = Math.floor(this.visibleHeight / this.errorEntryLines);
    if (this.cursorIndex < this.scrollOffset) {
      this.scrollOffset = this.cursorIndex;
    } else if (this.cursorIndex >= this.scrollOffset + maxEntries) {
      this.scrollOffset = this.cursorIndex - maxEntries + 1;
    }
    this.scrollOffset = Math.max(
      0,
      Math.min(this.scrollOffset, this.errors.length - 1),
    );
  }

  // ── HTTP helpers ───────────────────────────────────────────────────────

  private abortInFlight(): void {
    if (this.currentAbortController) {
      this.currentAbortController.abort();
      this.currentAbortController = undefined;
    }
  }

  private buildQueryParams(): Record<string, string> {
    const params: Record<string, string> = {};
    if (!this.showResolved) params.status = "unresolved";
    if (!this.showMuted) params.muted = "false";
    params.limit = String(this.limit);
    params.offset = String(this.offset);
    return params;
  }

  // ── Async operations ───────────────────────────────────────────────────

  toggleResolved(): void {
    this.retoggleFilter("resolved");
  }

  toggleMuted(): void {
    this.retoggleFilter("muted");
  }

  private retoggleFilter(filter: "resolved" | "muted"): void {
    if (this.mode === "loading") return;
    this.abortInFlight();

    if (filter === "resolved") {
      this.showResolved = !this.showResolved;
    } else {
      this.showMuted = !this.showMuted;
    }

    this.offset = 0;
    this.cursorIndex = 0;
    this.scrollOffset = 0;
    this.mode = "loading";
    this.invalidate();
    this.requestRender();

    const url = buildUrl(
      this.baseUrl,
      "/api/v1/errors",
      this.buildQueryParams(),
    );
    const controller = new AbortController();
    this.currentAbortController = controller;

    fetchErrors(url, this.token, controller.signal)
      .then((data) => {
        this.errors = data.errors;
        this.total = data.total;
        this.offset = data.offset ?? 0;
        this.cursorIndex = 0;
        this.scrollOffset = 0;
        this.clampCursor();
        this.clampViewport();
        this.mode = "list";
        this.invalidate();
        this.requestRender();
      })
      .catch((err) => {
        if (err instanceof Error && err.name === "AbortError") return;
        this.mode = "list";
        const msg = err instanceof Error ? err.message : String(err);
        this.notify(`Filter toggle (${filter}) failed: ${msg}`, "error");
        this.invalidate();
        this.requestRender();
      });
  }

  loadMore(): void {
    if (this.mode === "loading") return;
    if (this.offset + this.limit >= this.total) return; // end of results

    this.abortInFlight();
    this.offset = this.offset + this.limit;
    this.mode = "loading";
    this.invalidate();
    this.requestRender();

    const url = buildUrl(
      this.baseUrl,
      "/api/v1/errors",
      this.buildQueryParams(),
    );
    const controller = new AbortController();
    this.currentAbortController = controller;

    fetchErrors(url, this.token, controller.signal)
      .then((data) => {
        // Append new errors (deduplicate by id)
        const existingIds = new Set(this.errors.map((e) => e.id));
        const newErrors = data.errors.filter((e) => !existingIds.has(e.id));
        this.errors = [...this.errors, ...newErrors];
        this.total = data.total;
        // offset already incremented before fetch; keep it
        this.clampCursor();
        this.clampViewport();
        this.mode = "list";
        this.invalidate();
        this.requestRender();
      })
      .catch((err) => {
        if (err instanceof Error && err.name === "AbortError") return;
        // Revert offset on failure
        this.offset = this.offset - this.limit;
        this.mode = "list";
        const msg = err instanceof Error ? err.message : String(err);
        this.notify(`Load more failed: ${msg}`, "error");
        this.invalidate();
        this.requestRender();
      });
  }

  fetchDetail(id: number): void {
    if (this.mode === "loading") return;

    this.abortInFlight();
    this.mode = "loading";
    this.detailScrollOffset = 0;
    this.invalidate();
    this.requestRender();

    const url = buildUrl(this.baseUrl, `/api/v1/errors/${id}`);
    const controller = new AbortController();
    this.currentAbortController = controller;

    fetchError(url, this.token, controller.signal)
      .then((data) => {
        this.selectedError = data.error;
        this.detailScrollOffset = 0;
        this.mode = "detail";
        this.invalidate();
        this.requestRender();
      })
      .catch((err) => {
        if (err instanceof Error && err.name === "AbortError") return;
        this.mode = "list";
        const msg = err instanceof Error ? err.message : String(err);
        if (msg.includes("404")) {
          this.notify(`Error #${id} not found`, "warning");
        } else {
          this.notify(`Failed to load error detail: ${msg}`, "error");
        }
        this.invalidate();
        this.requestRender();
      });
  }

  toggleMute(id: number, currentMuted: boolean): void {
    if (this.mode === "loading") return;

    this.abortInFlight();
    this.mode = "loading";
    this.invalidate();
    this.requestRender();

    const action = currentMuted ? "unmute" : "mute";
    const url = buildUrl(this.baseUrl, `/api/v1/errors/${id}/${action}`);
    const controller = new AbortController();
    this.currentAbortController = controller;

    postApi<ErrorDetailResponse>(
      url,
      this.token,
      (data) => data as ErrorDetailResponse,
      controller.signal,
    )
      .then((data) => {
        // Update local error state in the list
        const idx = this.errors.findIndex((e) => e.id === id);
        if (idx !== -1) {
          const updated = data.error;
          this.errors[idx] = {
            ...this.errors[idx]!,
            muted: updated.muted,
          };
        }

        // Update detail view if viewing this error
        if (this.selectedError && this.selectedError.id === id) {
          this.selectedError = {
            ...this.selectedError,
            muted: data.error.muted,
          };
        }

        this.mode = this.selectedError ? "detail" : "list";
        this.notify(`Error #${id} ${action}d successfully`, "info");
        this.invalidate();
        this.requestRender();
      })
      .catch((err) => {
        if (err instanceof Error && err.name === "AbortError") return;
        this.mode = this.selectedError ? "detail" : "list";
        const msg = err instanceof Error ? err.message : String(err);
        this.notify(`Toggle mute failed: ${msg}`, "error");
        this.invalidate();
        this.requestRender();
      });
  }

  toggleResolve(id: number, currentStatus: string): void {
    if (this.mode === "loading") return;

    this.abortInFlight();
    this.mode = "loading";
    this.invalidate();
    this.requestRender();

    const action = currentStatus === "resolved" ? "unresolve" : "resolve";
    const url = buildUrl(this.baseUrl, `/api/v1/errors/${id}/${action}`);
    const controller = new AbortController();
    this.currentAbortController = controller;

    postApi<ErrorDetailResponse>(
      url,
      this.token,
      (data) => data as ErrorDetailResponse,
      controller.signal,
    )
      .then((data) => {
        // Update local error state in the list
        const idx = this.errors.findIndex((e) => e.id === id);
        if (idx !== -1) {
          const updated = data.error;
          this.errors[idx] = {
            ...this.errors[idx]!,
            status: updated.status,
          };
        }

        // Update detail view if viewing this error
        if (this.selectedError && this.selectedError.id === id) {
          this.selectedError = {
            ...this.selectedError,
            status: data.error.status,
          };
        }

        this.mode = this.selectedError ? "detail" : "list";
        this.notify(`Error #${id} ${action}d successfully`, "info");
        this.invalidate();
        this.requestRender();
      })
      .catch((err) => {
        if (err instanceof Error && err.name === "AbortError") return;
        this.mode = this.selectedError ? "detail" : "list";
        const msg = err instanceof Error ? err.message : String(err);
        this.notify(`Toggle resolve failed: ${msg}`, "error");
        this.invalidate();
        this.requestRender();
      });
  }

  // ── Input handling ─────────────────────────────────────────────────────

  handleInput(data: string): void {
    // Global keys (work in any mode)
    if (matchesKey(data, Key.escape)) {
      if (this.mode === "detail") {
        // Back to list
        this.mode = "list";
        this.selectedError = null;
        this.detailScrollOffset = 0;
        this.invalidate();
        return;
      }
      this.onClose?.();
      return;
    }

    if (matchesKey(data, "q")) {
      this.onClose?.();
      return;
    }

    // ── List mode keys ────────────────────────────────────────────────

    if (this.mode === "list" || this.mode === "loading") {
      if (matchesKey(data, "r")) {
        this.toggleResolved();
        return;
      }

      if (matchesKey(data, "m")) {
        this.toggleMuted();
        return;
      }

      if (matchesKey(data, Key.shift("r"))) {
        if (this.errors.length > 0 && this.cursorIndex >= 0) {
          const error = this.errors[this.cursorIndex];
          if (error) {
            this.toggleResolve(error.id, error.status);
          }
        }
        return;
      }

      if (matchesKey(data, Key.shift("m"))) {
        if (this.errors.length > 0 && this.cursorIndex >= 0) {
          const error = this.errors[this.cursorIndex];
          if (error) {
            this.toggleMute(error.id, error.muted);
          }
        }
        return;
      }

      if (matchesKey(data, "l")) {
        if (this.offset + this.limit >= this.total) return;
        this.loadMore();
        return;
      }

      if (matchesKey(data, Key.enter)) {
        if (this.errors.length > 0 && this.cursorIndex >= 0) {
          const error = this.errors[this.cursorIndex];
          if (error) {
            this.fetchDetail(error.id);
          }
        }
        return;
      }

      if (this.mode !== "list") return; // block navigation while loading

      let moved = false;

      if (matchesKey(data, Key.up) || matchesKey(data, "k")) {
        this.cursorIndex--;
        moved = true;
      } else if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
        this.cursorIndex++;
        moved = true;
      } else if (matchesKey(data, Key.pageUp)) {
        const pageSize = Math.floor(this.visibleHeight / this.errorEntryLines);
        this.cursorIndex -= pageSize;
        moved = true;
      } else if (
        matchesKey(data, Key.pageDown) ||
        matchesKey(data, Key.ctrl("f"))
      ) {
        const pageSize = Math.floor(this.visibleHeight / this.errorEntryLines);
        this.cursorIndex += pageSize;
        moved = true;
      } else if (matchesKey(data, Key.ctrl("b"))) {
        const pageSize = Math.floor(this.visibleHeight / this.errorEntryLines);
        this.cursorIndex -= pageSize;
        moved = true;
      } else if (matchesKey(data, Key.home) || matchesKey(data, "g")) {
        this.cursorIndex = 0;
        moved = true;
      } else if (
        matchesKey(data, Key.end) ||
        matchesKey(data, Key.shift("g"))
      ) {
        this.cursorIndex = this.errors.length - 1;
        moved = true;
      }

      if (moved) {
        this.clampCursor();
        this.clampViewport();
        this.invalidate();
      }

      return;
    }

    // ── Detail mode keys ───────────────────────────────────────────────

    if (this.mode === "detail") {
      if (matchesKey(data, Key.shift("r"))) {
        if (this.selectedError) {
          this.toggleResolve(this.selectedError.id, this.selectedError.status);
        }
        return;
      }

      if (matchesKey(data, Key.shift("m"))) {
        if (this.selectedError) {
          this.toggleMute(this.selectedError.id, this.selectedError.muted);
        }
        return;
      }

      if (matchesKey(data, Key.enter)) {
        // Copy current line to editor (prod-logs pattern)
        if (this.selectedError) {
          const detailLines = this.buildDetailLines();
          const idx = this.detailScrollOffset;
          if (idx < detailLines.length) {
            this.onCopy?.(detailLines[idx]!);
          }
        }
        return;
      }

      let moved = false;

      if (matchesKey(data, Key.up) || matchesKey(data, "k")) {
        this.detailScrollOffset--;
        moved = true;
      } else if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
        this.detailScrollOffset++;
        moved = true;
      } else if (matchesKey(data, Key.pageUp)) {
        this.detailScrollOffset -= this.visibleHeight;
        moved = true;
      } else if (
        matchesKey(data, Key.pageDown) ||
        matchesKey(data, Key.ctrl("f"))
      ) {
        this.detailScrollOffset += this.visibleHeight;
        moved = true;
      } else if (matchesKey(data, Key.ctrl("b"))) {
        this.detailScrollOffset -= this.visibleHeight;
        moved = true;
      } else if (matchesKey(data, Key.home) || matchesKey(data, "g")) {
        this.detailScrollOffset = 0;
        moved = true;
      } else if (
        matchesKey(data, Key.end) ||
        matchesKey(data, Key.shift("g"))
      ) {
        this.detailScrollOffset = Math.max(
          0,
          this.buildDetailLines().length - 1,
        );
        moved = true;
      }

      if (moved) {
        const maxOffset = Math.max(0, this.buildDetailLines().length - 1);
        this.detailScrollOffset = Math.max(
          0,
          Math.min(this.detailScrollOffset, maxOffset),
        );
        this.invalidate();
      }

      return;
    }
  }

  // ── Rendering ──────────────────────────────────────────────────────────

  render(width: number, theme: Theme): string[] {
    if (this.cachedLines && this.cachedWidth === width) {
      return this.cachedLines;
    }

    let result: string[];
    switch (this.mode) {
      case "loading":
        result = this.renderLoading(width, theme);
        break;
      case "detail":
        result = this.renderDetail(width, theme);
        break;
      default:
        result = this.renderList(width, theme);
        break;
    }

    this.cachedWidth = width;
    this.cachedLines = result;
    return result;
  }

  private renderLoading(width: number, theme: Theme): string[] {
    const border = theme.fg("accent", "─".repeat(width));
    const viewportRows = this.visibleHeight + 3; // +3 for chrome lines
    const mid = Math.floor(viewportRows / 2);
    const result: string[] = [border];

    for (let i = 1; i < viewportRows - 1; i++) {
      if (i === mid) {
        result.push(
          truncateToWidth(theme.fg("muted", "  Loading…"), width, ""),
        );
      } else {
        result.push("");
      }
    }

    result.push(border);
    return result;
  }

  private renderList(width: number, theme: Theme): string[] {
    const border = theme.fg("accent", "─".repeat(width));
    const result: string[] = [];

    // Top border
    result.push(border);

    // Header with counts
    const unresolvedCount = this.errors.filter(
      (e) => e.status === "unresolved",
    ).length;
    const headerText = ` Production Errors (${this.total} total${unresolvedCount > 0 ? `, ${unresolvedCount} unresolved` : ""})`;
    result.push(
      truncateToWidth(theme.fg("accent", theme.bold(headerText)), width, ""),
    );

    // Divider
    result.push(truncateToWidth(theme.fg("dim", "─".repeat(width)), width, ""));

    // Empty states
    if (this.errors.length === 0) {
      const msg =
        this.totalUnfiltered > 0
          ? "No errors match the current filters"
          : "No production errors found";
      result.push(truncateToWidth(theme.fg("muted", `  ${msg}`), width, ""));
      // Pad remaining viewport (3 chrome lines: border + header + divider)
      const chromeLines = 3;
      while (result.length < this.visibleHeight + chromeLines) {
        result.push("");
      }
    } else {
      // Render errors within viewport
      const maxEntries = Math.floor(this.visibleHeight / this.errorEntryLines);
      const endIdx = Math.min(
        this.scrollOffset + maxEntries,
        this.errors.length,
      );

      let linesRendered = 0;
      for (let i = this.scrollOffset; i < endIdx; i++) {
        const error = this.errors[i];
        if (!error) continue;

        const isCursor = i === this.cursorIndex;
        const cursor = isCursor ? "▶" : " ";

        // Status badge color
        let statusColor = "muted";
        if (error.status === "unresolved") statusColor = "error";
        else if (error.status === "resolved") statusColor = "success";

        const mutedLabel = error.muted ? " [MUTED]" : "";
        const statusBadge = theme.fg(
          statusColor,
          `[${error.status.toUpperCase()}]`,
        );

        // Line 1: cursor + status badge + kind + truncated reason
        const reasonText = truncateReason(
          error.reason,
          Math.max(30, width - 25),
        );
        const line1 = `${cursor} ${statusBadge}${mutedLabel} ${error.kind}: ${reasonText}`;
        result.push(
          truncateToWidth(
            isCursor ? theme.fg("accent", line1) : line1,
            width,
            "",
          ),
        );

        // Line 2: source info
        const sourceInfo = error.source_function
          ? `  ${error.source_function}  ${error.source_line || ""}`
          : `  ${error.source_line || "(no source)"}`;
        result.push(truncateToWidth(theme.fg("dim", sourceInfo), width, ""));

        // Line 3: last seen relative time
        const lastSeen = error.last_occurrence_at
          ? `  Last seen ${formatRelativeTime(error.last_occurrence_at)}`
          : "  No occurrences";
        result.push(truncateToWidth(theme.fg("dim", lastSeen), width, ""));

        linesRendered += this.errorEntryLines;
      }

      // Pad remaining viewport if fewer lines than visible
      const targetLines = 3 + this.visibleHeight;
      while (result.length < targetLines) {
        result.push("");
      }
    }

    // Help lines
    const resolvedLabel = this.showResolved ? "hide" : "show";
    const mutedLabel = this.showMuted ? "hide" : "show";
    const hasMore = this.offset + this.limit < this.total;

    result.push(
      truncateToWidth(
        theme.fg(
          "dim",
          ` ↑↓/jk navigate  ↵ details  r ${resolvedLabel} resolved  m ${mutedLabel} muted  M toggle mute  R toggle resolve`,
        ),
        width,
        "",
      ),
    );
    result.push(
      truncateToWidth(
        theme.fg(
          "dim",
          hasMore ? ` l load more  q quit` : ` — end of results —  q quit`,
        ),
        width,
        "",
      ),
    );

    // Bottom border
    result.push(border);

    return result;
  }

  private buildDetailLines(): string[] {
    const error = this.selectedError;
    if (!error) return ["(no error selected)"];
    return formatDetailLines(error);
  }

  private renderDetail(width: number, theme: Theme): string[] {
    const border = theme.fg("accent", "─".repeat(width));
    const result: string[] = [];

    // Top border
    result.push(border);

    // Header
    const error = this.selectedError;
    const headerText = error
      ? ` Error #${error.id}: ${error.kind}`
      : " Error Detail";
    result.push(
      truncateToWidth(theme.fg("accent", theme.bold(headerText)), width, ""),
    );

    // Divider
    result.push(truncateToWidth(theme.fg("dim", "─".repeat(width)), width, ""));

    // Detail content (scrolled)
    const detailLines = this.buildDetailLines();
    const endIdx = Math.min(
      this.detailScrollOffset + this.visibleHeight,
      detailLines.length,
    );

    for (let i = this.detailScrollOffset; i < endIdx; i++) {
      result.push(truncateToWidth(`  ${detailLines[i]}`, width, ""));
    }

    // Pad remaining viewport
    const targetLines = 3 + this.visibleHeight;
    while (result.length < targetLines) {
      result.push("");
    }

    // Help line
    const fromLine = this.detailScrollOffset + 1;
    const toLine = Math.min(
      this.detailScrollOffset + this.visibleHeight,
      detailLines.length,
    );
    const pct =
      detailLines.length > 0
        ? Math.round((this.detailScrollOffset / detailLines.length) * 100)
        : 0;
    result.push(
      truncateToWidth(
        theme.fg(
          "dim",
          ` Lines ${fromLine}-${toLine} of ${detailLines.length} (${pct}%)  ↑↓/jk scroll  Enter copy  M mute  R resolve  Escape back`,
        ),
        width,
        "",
      ),
    );

    // Bottom border
    result.push(border);

    return result;
  }

  invalidate(): void {
    this.cachedWidth = undefined;
    this.cachedLines = undefined;
  }
}

// ── Extension ───────────────────────────────────────────────────────────────

export default function prodErrorsExtension(pi: ExtensionAPI) {
  // ── fetch_production_errors tool ───────────────────────────────────────

  pi.registerTool({
    name: "fetch_production_errors",
    label: "Fetch Production Errors",
    description:
      "Fetch production errors from the deployed application via the /api/v1/errors JSON API. " +
      "Use this tool when investigating what errors are occurring in production, " +
      "checking error frequency, browsing unresolved errors, or when the user asks " +
      "about production errors. Supports filtering by status, muted state, and " +
      "substring search on error reason. Output is truncated at 50KB / 2000 lines " +
      "— use narrower filters to reduce output if truncation occurs.",
    promptSnippet:
      "Fetch recent production errors from the errors API (params: status, muted, search, limit, offset)",
    promptGuidelines: [
      "Use fetch_production_errors when investigating what errors are occurring in production, checking error frequency, or browsing unresolved errors.",
      "Start with a small limit (e.g., 20) and filter by status or search before fetching large result sets. Use the 'search' parameter to find errors matching a specific reason or module.",
      "Use fetch_production_error when you need full details on a specific error, including stacktraces and context. Get the error ID from fetch_production_errors first.",
    ],
    parameters: Type.Object({
      status: Type.Optional(
        Type.Union([Type.Literal("resolved"), Type.Literal("unresolved")], {
          description: "Filter by error status: 'resolved' or 'unresolved'.",
        }),
      ),
      muted: Type.Optional(
        Type.Boolean({
          description:
            "Filter by muted state. true = only muted, false = only unmuted.",
        }),
      ),
      search: Type.Optional(
        Type.String({
          description:
            "Substring match on error reason. Case-insensitive search to find specific errors.",
        }),
      ),
      limit: Type.Optional(
        Type.Number({
          description:
            "Maximum number of errors to return. Default: 50. Use a smaller value to reduce output size.",
        }),
      ),
      offset: Type.Optional(
        Type.Number({
          description:
            "Pagination offset. Number of errors to skip. Default: 0.",
        }),
      ),
    }),
    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
      // Early abort check
      if (signal?.aborted) {
        return { content: [{ type: "text", text: "Cancelled" }] };
      }

      // Validate credentials
      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        return {
          content: [
            {
              type: "text",
              text:
                `Cannot fetch production errors: the following environment variables are not set:\n` +
                missing.map((v) => `  - ${v}`).join("\n") +
                `\n\nEnsure these are configured in your pi environment.`,
            },
          ],
          isError: true,
        };
      }

      // Build query params for non-nil values
      const queryParams: Record<string, string> = {};
      if (params.status !== undefined && params.status !== null) {
        queryParams.status = params.status;
      }
      if (params.muted !== undefined && params.muted !== null) {
        queryParams.muted = String(params.muted);
      }
      if (
        params.search !== undefined &&
        params.search !== null &&
        params.search !== ""
      ) {
        queryParams.search = params.search;
      }
      if (params.limit !== undefined && params.limit !== null) {
        queryParams.limit = String(params.limit);
      }
      if (params.offset !== undefined && params.offset !== null) {
        queryParams.offset = String(params.offset);
      }

      const url = buildUrl(fqdn!, "/api/v1/errors", queryParams);

      // Fetch
      let data: ErrorListResponse;
      try {
        data = await fetchErrors(url, token!, signal);
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        return {
          content: [
            {
              type: "text",
              text: `Failed to fetch production errors: ${message}`,
            },
          ],
          isError: true,
        };
      }

      // Handle empty results
      if (data.errors.length === 0) {
        return {
          content: [
            {
              type: "text",
              text: "No errors found matching the given filters.",
            },
          ],
          details: {
            total: data.total,
            count: 0,
            offset: data.offset,
            limit: data.limit,
          },
        };
      }

      // Format output
      const count = data.errors.length;
      const from = (data.offset ?? 0) + 1;
      const to = (data.offset ?? 0) + count;

      const header = `Production Errors (total: ${data.total}, showing ${from}-${to})\n`;
      const body = data.errors
        .map((e, i) => formatErrorListItem(e, from + i))
        .join("\n\n");

      const output = applyOutputTruncation(header + body);

      return {
        content: [{ type: "text", text: output }],
        details: {
          total: data.total,
          count,
          offset: data.offset,
          limit: data.limit,
        },
      };
    },
  });

  // ── fetch_production_error tool ────────────────────────────────────────

  pi.registerTool({
    name: "fetch_production_error",
    label: "Fetch Production Error Detail",
    description:
      "Fetch full details for a specific production error by ID, including all " +
      "occurrences, stacktraces, context, and breadcrumbs. Use this tool when you " +
      "need to investigate a specific error in depth. Get the error ID from " +
      "fetch_production_errors first. Output is truncated at 50KB / 2000 lines.",
    promptSnippet:
      "Fetch full details for a specific production error by ID (param: id)",
    promptGuidelines: [
      "Use fetch_production_error when you need full details on a specific error, including stacktraces, context, and breadcrumbs from every occurrence.",
      "Get the error ID from fetch_production_errors first. Pass it as the 'id' parameter. The output includes all occurrences and may be large — review it carefully before asking for more.",
    ],
    parameters: Type.Object({
      id: Type.Number({
        description:
          "The error ID (integer) to fetch full details for. Get this from fetch_production_errors.",
      }),
    }),
    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
      // Early abort check
      if (signal?.aborted) {
        return { content: [{ type: "text", text: "Cancelled" }] };
      }

      // Validate credentials
      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        return {
          content: [
            {
              type: "text",
              text:
                `Cannot fetch production error: the following environment variables are not set:\n` +
                missing.map((v) => `  - ${v}`).join("\n") +
                `\n\nEnsure these are configured in your pi environment.`,
            },
          ],
          isError: true,
        };
      }

      const url = buildUrl(fqdn!, `/api/v1/errors/${params.id}`);

      // Fetch
      let data: ErrorDetailResponse;
      try {
        data = await fetchError(url, token!, signal);
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        // Check if it looks like a 404
        if (message.includes("404")) {
          return {
            content: [
              {
                type: "text",
                text: `Error with ID ${params.id} not found.`,
              },
            ],
            isError: true,
          };
        }
        return {
          content: [
            {
              type: "text",
              text: `Failed to fetch production error: ${message}`,
            },
          ],
          isError: true,
        };
      }

      // Format output
      const output = applyOutputTruncation(formatErrorDetail(data.error));

      return {
        content: [{ type: "text", text: output }],
        details: {
          errorId: params.id,
          occurrenceCount: data.error.occurrence_count,
        },
      };
    },
  });

  // ── mute_production_error tool ─────────────────────────────────────────

  pi.registerTool({
    name: "mute_production_error",
    label: "Mute Production Error",
    description:
      "Mute a production error by ID. Muted errors will not trigger email " +
      "notifications. Use this tool to silence noisy or already-addressed errors.",
    promptSnippet:
      "Mute a production error by ID to suppress email notifications",
    promptGuidelines: [
      "Use mute_production_error to silence notifications for a noisy or already-addressed production error.",
      "Get the error ID from fetch_production_errors first. Muted errors still appear in listings but show a [MUTED] label.",
    ],
    parameters: Type.Object({
      id: Type.Number({
        description:
          "The error ID (integer) to mute. Get this from fetch_production_errors.",
      }),
    }),
    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
      if (signal?.aborted) {
        return { content: [{ type: "text", text: "Cancelled" }] };
      }

      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        return {
          content: [
            {
              type: "text",
              text:
                `Cannot mute production error: the following environment variables are not set:\n` +
                missing.map((v) => `  - ${v}`).join("\n") +
                `\n\nEnsure these are configured in your pi environment.`,
            },
          ],
          isError: true,
        };
      }

      try {
        const data = await postApi<ErrorDetailResponse>(
          buildUrl(fqdn!, `/api/v1/errors/${params.id}/mute`),
          token!,
          (data) => data as ErrorDetailResponse,
          signal,
        );

        return {
          content: [
            {
              type: "text",
              text:
                `Error #${params.id} muted successfully.` +
                (data.error?.muted
                  ? ""
                  : " (Warning: muted field not reflected in response)"),
            },
          ],
          details: { errorId: params.id, muted: data.error?.muted },
        };
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        if (message.includes("404")) {
          return {
            content: [
              {
                type: "text",
                text: `Error with ID ${params.id} not found.`,
              },
            ],
            isError: true,
          };
        }
        return {
          content: [
            {
              type: "text",
              text: `Failed to mute production error: ${message}`,
            },
          ],
          isError: true,
        };
      }
    },
  });

  // ── unmute_production_error tool ───────────────────────────────────────

  pi.registerTool({
    name: "unmute_production_error",
    label: "Unmute Production Error",
    description:
      "Unmute a previously muted production error by ID, re-enabling email " +
      "notifications for new occurrences.",
    promptSnippet:
      "Unmute a production error by ID to re-enable email notifications",
    promptGuidelines: [
      "Use unmute_production_error to re-enable notifications for a previously muted error.",
      "Get the error ID from fetch_production_errors first.",
    ],
    parameters: Type.Object({
      id: Type.Number({
        description:
          "The error ID (integer) to unmute. Get this from fetch_production_errors.",
      }),
    }),
    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
      if (signal?.aborted) {
        return { content: [{ type: "text", text: "Cancelled" }] };
      }

      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        return {
          content: [
            {
              type: "text",
              text:
                `Cannot unmute production error: the following environment variables are not set:\n` +
                missing.map((v) => `  - ${v}`).join("\n") +
                `\n\nEnsure these are configured in your pi environment.`,
            },
          ],
          isError: true,
        };
      }

      try {
        const data = await postApi<ErrorDetailResponse>(
          buildUrl(fqdn!, `/api/v1/errors/${params.id}/unmute`),
          token!,
          (data) => data as ErrorDetailResponse,
          signal,
        );

        return {
          content: [
            {
              type: "text",
              text: `Error #${params.id} unmuted successfully. Email notifications will resume for new occurrences.`,
            },
          ],
          details: { errorId: params.id, muted: data.error?.muted },
        };
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        if (message.includes("404")) {
          return {
            content: [
              {
                type: "text",
                text: `Error with ID ${params.id} not found.`,
              },
            ],
            isError: true,
          };
        }
        return {
          content: [
            {
              type: "text",
              text: `Failed to unmute production error: ${message}`,
            },
          ],
          isError: true,
        };
      }
    },
  });

  // ── resolve_production_error tool ───────────────────────────────────────

  pi.registerTool({
    name: "resolve_production_error",
    label: "Resolve Production Error",
    description:
      "Mark a production error as resolved by ID. Resolved errors are filtered " +
      "out of the default unresolved view.",
    promptSnippet:
      "Mark a production error as resolved when the underlying issue has been fixed",
    promptGuidelines: [
      "Use resolve_production_error to mark a production error as resolved when the underlying issue has been fixed.",
      "Get the error ID from fetch_production_errors first.",
    ],
    parameters: Type.Object({
      id: Type.Number({
        description:
          "The error ID (integer) to resolve. Get this from fetch_production_errors.",
      }),
    }),
    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
      if (signal?.aborted) {
        return { content: [{ type: "text", text: "Cancelled" }] };
      }

      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        return {
          content: [
            {
              type: "text",
              text:
                `Cannot resolve production error: the following environment variables are not set:\n` +
                missing.map((v) => `  - ${v}`).join("\n") +
                `\n\nEnsure these are configured in your pi environment.`,
            },
          ],
          isError: true,
        };
      }

      try {
        const data = await postApi<ErrorDetailResponse>(
          buildUrl(fqdn!, `/api/v1/errors/${params.id}/resolve`),
          token!,
          (data) => data as ErrorDetailResponse,
          signal,
        );

        return {
          content: [
            {
              type: "text",
              text:
                `Error #${params.id} resolved successfully.` +
                (data.error?.status === "resolved"
                  ? ""
                  : " (Warning: status field not reflected in response)"),
            },
          ],
          details: { errorId: params.id, status: data.error?.status },
        };
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        if (message.includes("404")) {
          return {
            content: [
              {
                type: "text",
                text: `Error with ID ${params.id} not found.`,
              },
            ],
            isError: true,
          };
        }
        return {
          content: [
            {
              type: "text",
              text: `Failed to resolve production error: ${message}`,
            },
          ],
          isError: true,
        };
      }
    },
  });

  // ── unresolve_production_error tool ─────────────────────────────────────

  pi.registerTool({
    name: "unresolve_production_error",
    label: "Unresolve Production Error",
    description:
      "Reopen a previously resolved production error by ID. Use when an error " +
      "reoccurs after being marked as resolved.",
    promptSnippet:
      "Reopen a production error when it reoccurs after being resolved",
    promptGuidelines: [
      "Use unresolve_production_error to reopen a production error when it reoccurs after being resolved.",
      "Get the error ID from fetch_production_errors first.",
    ],
    parameters: Type.Object({
      id: Type.Number({
        description:
          "The error ID (integer) to unresolve. Get this from fetch_production_errors.",
      }),
    }),
    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
      if (signal?.aborted) {
        return { content: [{ type: "text", text: "Cancelled" }] };
      }

      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        return {
          content: [
            {
              type: "text",
              text:
                `Cannot unresolve production error: the following environment variables are not set:\n` +
                missing.map((v) => `  - ${v}`).join("\n") +
                `\n\nEnsure these are configured in your pi environment.`,
            },
          ],
          isError: true,
        };
      }

      try {
        const data = await postApi<ErrorDetailResponse>(
          buildUrl(fqdn!, `/api/v1/errors/${params.id}/unresolve`),
          token!,
          (data) => data as ErrorDetailResponse,
          signal,
        );

        return {
          content: [
            {
              type: "text",
              text: `Error #${params.id} reopened (unresolved) successfully.`,
            },
          ],
          details: { errorId: params.id, status: data.error?.status },
        };
      } catch (err) {
        const message = err instanceof Error ? err.message : String(err);
        if (message.includes("404")) {
          return {
            content: [
              {
                type: "text",
                text: `Error with ID ${params.id} not found.`,
              },
            ],
            isError: true,
          };
        }
        return {
          content: [
            {
              type: "text",
              text: `Failed to unresolve production error: ${message}`,
            },
          ],
          isError: true,
        };
      }
    },
  });

  // ── /prod-errors interactive command ──────────────────────────────────

  pi.registerCommand("prod-errors", {
    description:
      "Browse production errors interactively via the /api/v1/errors JSON API",
    handler: async (_args, ctx) => {
      // ── Validate credentials ────────────────────────────────────────

      const token = resolveVar("api_token");
      const fqdn = resolveVar("service_fqdn_web");

      const missing: string[] = [];
      if (!token) missing.push("PI_API_TOKEN");
      if (!fqdn) missing.push("PI_SERVICE_FQDN_WEB");

      if (missing.length > 0) {
        ctx.ui.notify(
          `Missing environment variables: ${missing.join(", ")}`,
          "error",
        );
        return;
      }

      // ── Fetch initial errors with loader UI ─────────────────────────

      const errorsData = await ctx.ui.custom<ErrorListResponse | null>(
        (tui, theme, _kb, done) => {
          const loader = new BorderedLoader(
            tui,
            theme,
            "Fetching production errors...",
          );
          loader.onAbort = () => done(null);

          const url = buildUrl(fqdn!, "/api/v1/errors", {
            limit: "50",
            offset: "0",
          });

          fetchErrors(url, token!, loader.signal)
            .then(done)
            .catch((err) => {
              console.error("[prod-errors] Initial fetch failed:", err);
              done(null);
            });

          return loader;
        },
      );

      if (errorsData === null) {
        ctx.ui.notify(
          "Cancelled or fetch failed — check logs for details",
          "info",
        );
        return;
      }

      if (errorsData.errors.length === 0) {
        ctx.ui.notify("No production errors found", "info");
        return;
      }

      // ── Interactive error browser ────────────────────────────────────

      const baseUrl = fqdn!;
      const apiToken = token!;

      const copiedText = await ctx.ui.custom<string | null>(
        (tui, theme, _kb, done) => {
          const browser = new ErrorBrowser(
            errorsData.errors,
            errorsData.total,
            baseUrl,
            apiToken,
            () => tui.requestRender(),
            (msg, level) => ctx.ui.notify(msg, level),
          );

          browser.onClose = () => done(null);
          browser.onCopy = (text: string) => done(text);

          return {
            render(width: number) {
              return browser.render(width, theme);
            },
            invalidate() {
              browser.invalidate();
            },
            handleInput(data: string) {
              browser.handleInput(data);
              tui.requestRender();
            },
          };
        },
      );

      // ── Place copied text in editor ──────────────────────────────────

      if (copiedText !== null) {
        ctx.ui.setEditorText(copiedText);
      }

      ctx.ui.notify("Error browser closed", "info");
    },
  });
}