pi-unsloth-webtools 0.7.6 → 0.9.0

package/web-fetch.ts

@@ -2,6 +2,7 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import type { LookupAllOptions } from "node:dns";
 import http from "node:http";
 import https from "node:https";
+import { isIP } from "node:net";
 import { open } from "node:fs/promises";
 import type { FileHandle } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -19,9 +20,11 @@ import {
   isPublicIp,
   MAX_SIGNAL_TIMEOUT_MS,
   normalizeUrlScheme,
+  stripIpv6Brackets,
   type WebsitePolicy,
 } from "./web-access.ts";
-import { collapseWhitespace, decodeHtmlEntities, feedHtml, htmlToMarkdown } from "./html-to-md.ts";
+import { impersonatedRequest, type TlsHopOptions, type TlsHopResponse } from "./tls-fetch.ts";
+import { collapseWhitespace, decodeHtmlEntities, feedHtml, htmlToMarkdown, visibleChars } from "./html-to-md.ts";
 import type { AttrDict } from "./html-to-md.ts";
 import { INVALID_CHARREFS } from "./entities.ts";
 import { getCached, isFresh, setCached, staleNotice } from "./cache.ts";
@@ -125,6 +128,14 @@ const HTML_LEADING_RE = new RegExp(
 );
 const HTML_DOCUMENT_RE = /^<(?:!doctype\s+html\b|\/?(?:html|head|body)\b)/;
 
+const RENDER_THIN_PROSE_CHARS = 400;
+const RENDER_SCRIPT_SHARE = 0.5;
+const RENDER_SCRIPT_MIN_HTML_BYTES = 8192;
+const RENDER_MIN_SCRIPTS = 3;
+const RENDER_NOSCRIPT_MIN_CHARS = 40;
+const RENDER_SPA_MARKERS =
+  /(?:id\s*=\s*["']?(?:root|app|__next|__nuxt)["']?|data-reactroot|ng-version|__NEXT_DATA__|__NUXT__|__PRELOADED_STATE__)/i;
+
 const MIN_SINGLE_BYTE_ASCII_RATIO = 3 / 4;
 const ASCII_TEXT_BYTES = new Set<number>([
   ...Array.from({ length: 0x7f - 0x20 }, (_, i) => i + 0x20),
@@ -147,8 +158,8 @@ export class FetchTimeoutError extends Error {
 }
 const FETCH_CANCELLED_MESSAGE = "Failed to fetch URL: cancelled.";
 const FETCH_TIMEOUT_MESSAGE = "Failed to fetch URL: timed out.";
-const TRUNCATED_BODY_SUFFIX = "... (page truncated at the download limit)";
-const TRUNCATED_BODY_NOTICE = "\n\n" + TRUNCATED_BODY_SUFFIX;
+export const TRUNCATED_BODY_SUFFIX = "... (page truncated at the download limit)";
+export const TRUNCATED_BODY_NOTICE = "\n\n" + TRUNCATED_BODY_SUFFIX;
 
 function fetchErrorMessage(err: unknown): string {
   if (err instanceof FetchCancelledError) return FETCH_CANCELLED_MESSAGE;
@@ -178,6 +189,7 @@ export interface FetchPageOptions {
   maxBytes?: number;
   maxPdfBytes?: number;
   allowPrivateAddresses?: boolean;
+  transport?: FetchTransport;
   allowLocalFiles?: boolean;
   seams?: FetchSeams;
   rawFetch?: (url: string, options: RawFetchOptions) => Promise<RawFetchResult>;
@@ -198,9 +210,13 @@ export interface ResolvedHost {
   alternates?: { ip: string; family: number }[];
 }
 
+export type FetchTransport = "tls-first" | "direct-first" | "off";
+
+type TransportKind = "direct" | "tls";
 export interface FetchSeams {
   resolve?: (hostname: string, signal?: AbortSignal, allowPrivateAddresses?: boolean) => Promise<ResolvedHost>;
   request?: (opts: HopOptions) => Promise<HopResponse>;
+  impersonate?: (options: TlsHopOptions) => Promise<TlsHopResponse | null>;
 }
 
 export interface HopOptions {
@@ -226,6 +242,7 @@ export interface RawFetchOptions {
   maxBytes?: number;
   maxPdfBytes?: number;
   allowPrivateAddresses?: boolean;
+  transport?: FetchTransport;
   seams?: FetchSeams;
 }
 
@@ -235,6 +252,16 @@ export interface RawFetchResult {
   contentType: string;
 }
 
+export interface RenderHint {
+  reason: "empty" | "js-shell";
+  evidence: string[];
+}
+
+export interface FetchPageOutcome {
+  text: string;
+  hint: RenderHint | null;
+}
+
 function htmlProbe(body: string, re: RegExp): boolean {
   let i = 0;
   const n = body.length;
@@ -265,6 +292,46 @@ export function looksLikeHtmlDocument(body: string): boolean {
   return htmlProbe(body, HTML_DOCUMENT_RE);
 }
 
+function noscriptText(html: string): string {
+  const parts: string[] = [];
+  for (const match of html.match(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi) ?? []) {
+    parts.push(match.replace(/<[^>]*>/g, " "));
+  }
+  return collapseWhitespace(decodeHtmlEntities(parts.join(" ")));
+}
+
+export function needsRenderHint(html: string, converted: string): RenderHint | null {
+  const prose = visibleChars(converted);
+  if (prose >= RENDER_THIN_PROSE_CHARS) return null;
+  if (prose === 0) return { reason: "empty", evidence: [] };
+  const evidence: string[] = [];
+  let score = 0;
+  if (RENDER_SPA_MARKERS.test(html)) {
+    evidence.push("spa-markers");
+    score += 2;
+  }
+  const scriptCount = (html.match(/<script\b/gi) ?? []).length;
+  let scriptBytes = 0;
+  for (const script of html.match(/<script\b[^>]*>[\s\S]*?<\/script>/gi) ?? []) scriptBytes += script.length;
+  if (html.length >= RENDER_SCRIPT_MIN_HTML_BYTES && scriptBytes >= html.length * RENDER_SCRIPT_SHARE) {
+    evidence.push("script-heavy");
+    score += 2;
+  }
+  if (scriptCount >= RENDER_MIN_SCRIPTS) {
+    evidence.push("scripts");
+    score += 1;
+  }
+  if (noscriptText(html).length >= RENDER_NOSCRIPT_MIN_CHARS) {
+    evidence.push("noscript");
+    score += 1;
+  }
+  if (extractPageMeta(html).description) {
+    evidence.push("description");
+    score += 1;
+  }
+  return score >= 2 ? { reason: "js-shell", evidence } : null;
+}
+
 function parseContentType(value: string | null | undefined): string {
   return /^[\w.+-]+\/[\w.+-]+/.exec(value ?? "")?.[0] ?? "";
 }
@@ -320,7 +387,7 @@ function hasSingleByteTextEvidence(data: Buffer): boolean {
   return ascii / data.length >= MIN_SINGLE_BYTE_ASCII_RATIO;
 }
 
-const CHARSET_ALIASES: Record<string, string> = {
+const CHARSET_ALIASES: Record<string, string> = Object.assign(Object.create(null), {
   gbk: "gbk",
   gb2312: "gbk",
   "gb-2312": "gbk",
@@ -346,7 +413,7 @@ const CHARSET_ALIASES: Record<string, string> = {
   "windows-874": "windows-874",
   cp874: "windows-874",
   "tis-620": "tis-620",
-};
+});
 
 function normalizeCharset(name: string): string | null {
   const n = name.trim().replace(/["']/g, "").toLowerCase();
@@ -637,9 +704,10 @@ export function requestHop(opts: HopOptions): Promise<HopResponse> {
     const url = opts.url;
     const transport = url.protocol === "https:" ? https : http;
     const port = url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80;
+    const hostname = stripIpv6Brackets(url.hostname);
     const options: https.RequestOptions = {
       method: "GET",
-      host: url.hostname,
+      host: hostname,
       port,
       path: url.pathname + url.search,
       headers: opts.headers,
@@ -652,12 +720,12 @@ export function requestHop(opts: HopOptions): Promise<HopResponse> {
         ip: opts.pinnedIp,
         family: opts.family,
         port,
-        servername: url.hostname,
+        servername: hostname,
         timeoutMs: Math.max(1, opts.inactivityMs),
         signal: opts.signal,
       });
     } else {
-      options.servername = url.protocol === "https:" ? url.hostname : undefined;
+      options.servername = url.protocol === "https:" && !isIP(hostname) ? hostname : undefined;
       options.lookup = ((_hostname: string, _options: unknown, _callback: unknown) => {
         const done = (typeof _options === "function" ? _options : _callback) as (err: unknown, address: unknown, family?: unknown) => void;
         if ((_options as { all?: boolean } | undefined)?.all) {
@@ -842,6 +910,10 @@ export async function fetchUrlRaw(
   const resolveHost = seams.resolve ?? resolveAndValidateHost;
   const allowPrivateAddresses = options.allowPrivateAddresses ?? true;
   const performRequest = seams.request ?? requestHop;
+  const transportMode = options.transport ?? "tls-first";
+  const performImpersonation =
+    transportMode === "off" ? null : (seams.impersonate ?? (seams.request ? null : impersonatedRequest));
+  const directFirst = transportMode === "direct-first" || performImpersonation === null;
   const resolveWithBudget = async (hostname: string): Promise<ResolvedHost> => {
     const abortController = new AbortController();
     const waitMs = clampedRemainingMs(deadline, now);
@@ -876,14 +948,16 @@ export async function fetchUrlRaw(
   let pinnedFamily = resolved.family;
   let alternates: { ip: string; family: number }[] = resolved.alternates ?? [];
   let alternateIndex = 0;
+  const triedTransports = new Set<string>();
   const userAgent = randomUserAgent();
   for (let hop = 0; hop < MAX_REQUESTS; hop++) {
     const budgetResult = checkBudget();
     if (budgetResult !== null) return budgetResult;
     const parsed = new URL(currentUrl);
-    const hostHeader = parsed.hostname.includes(":")
-      ? `[${parsed.hostname}]${parsed.port ? `:${parsed.port}` : ""}`
-      : parsed.hostname + (parsed.port ? `:${parsed.port}` : "");
+    const parsedHostname = stripIpv6Brackets(parsed.hostname);
+    const hostHeader = parsedHostname.includes(":")
+      ? `[${parsedHostname}]${parsed.port ? `:${parsed.port}` : ""}`
+      : parsedHostname + (parsed.port ? `:${parsed.port}` : "");
     const headers: Record<string, string> = {
       "User-Agent": userAgent,
       Host: hostHeader,
@@ -898,34 +972,67 @@ export async function fetchUrlRaw(
     }
     headers["Host"] = hostHeader;
     const inactivity = remainingMs(deadline, now);
-    let response: HopResponse;
-    try {
-      response = await performRequest({
-        url: parsed,
-        pinnedIp,
-        family: pinnedFamily,
-        headers,
-        maxBytes,
-        maxPdfBytes,
-        inactivityMs: inactivity,
-        deadlineMs: deadline,
-        nowMs: now,
-        signal,
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "";
-      if (message === "cancelled" || message === "timed out") return emptyResult(fetchErrorMessage(err));
-      if (
-        !(err instanceof FetchCancelledError) &&
-        !(err instanceof FetchTimeoutError) &&
-        alternateIndex < alternates.length
-      ) {
+    const order: TransportKind[] = socksProxyForUrl(parsed) !== null
+      ? ["direct"]
+      : directFirst
+        ? ["direct", "tls"]
+        : ["tls", "direct"];
+    let response: HopResponse | null = null;
+    let failure: unknown = null;
+    for (const kind of order) {
+      const key = `${kind}|${currentUrl}|${pinnedIp}`;
+      if (triedTransports.has(key)) continue;
+      triedTransports.add(key);
+      let attempt: HopResponse | null;
+      try {
+        if (kind === "tls") {
+          const impersonate = performImpersonation;
+          if (impersonate === null) continue;
+          attempt = await impersonate({
+            url: parsed,
+            pinnedIp,
+            family: pinnedFamily,
+            timeoutMs: remainingMs(deadline, now),
+            signal,
+            maxBytes,
+            maxPdfBytes,
+            extraHeaders: options.extraHeaders,
+          });
+        } else {
+          attempt = await performRequest({
+            url: parsed,
+            pinnedIp,
+            family: pinnedFamily,
+            headers,
+            maxBytes,
+            maxPdfBytes,
+            inactivityMs: inactivity,
+            deadlineMs: deadline,
+            nowMs: now,
+            signal,
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "";
+        if (message === "cancelled" || message === "timed out") return emptyResult(fetchErrorMessage(err));
+        if (err instanceof FetchCancelledError || err instanceof FetchTimeoutError) {
+          return emptyResult(fetchErrorMessage(err));
+        }
+        failure = err;
+        continue;
+      }
+      if (attempt === null) continue;
+      if (response === null || (attempt.status < 400 && response.status >= 400)) response = attempt;
+      if (attempt.status < 400) break;
+    }
+    if (response === null) {
+      if (alternateIndex < alternates.length) {
         const next = alternates[alternateIndex++];
         pinnedIp = next.ip;
         pinnedFamily = next.family;
         continue;
       }
-      return emptyResult(fetchErrorMessage(err));
+      return emptyResult(fetchErrorMessage(failure ?? new Error("no transport could reach the target")));
     }
 
     if (response.status >= 300 && response.status < 400) {
@@ -1133,9 +1240,10 @@ interface PageMeta {
   author: string;
   date: string;
   site: string;
+  description: string;
 }
 
-const META_KEYS: Record<string, keyof PageMeta> = {
+const META_KEYS: Record<string, keyof PageMeta> = Object.assign(Object.create(null), {
   author: "author",
   "article:author": "author",
   "dc.creator": "author",
@@ -1145,7 +1253,9 @@ const META_KEYS: Record<string, keyof PageMeta> = {
   datepublished: "date",
   "og:site_name": "site",
   "application-name": "site",
-};
+  description: "description",
+  "og:description": "description",
+});
 
 function cutAtCharBoundary(text: string, maxChars: number): string {
   const sliced = text.slice(0, maxChars);
@@ -1165,7 +1275,7 @@ function capMetaValue(value: string): string {
 }
 
 function extractPageMeta(html: string): PageMeta {
-  const meta: PageMeta = { title: extractPageTitle(html), author: "", date: "", site: "" };
+  const meta: PageMeta = { title: extractPageTitle(html), author: "", date: "", site: "", description: "" };
   const seen = new Set<string>();
   const record = (name: string, attrs: AttrDict) => {
     if (name !== "meta") return;
@@ -1191,7 +1301,7 @@ function extractPageMeta(html: string): PageMeta {
   return meta;
 }
 
-function pagePrefixedMarkdown(html: string): string {
+export function pagePrefixedMarkdown(html: string): string {
   const meta = extractPageMeta(html);
   const lines: string[] = [];
   if (meta.title) lines.push(`Title: ${meta.title}`);
@@ -1291,6 +1401,13 @@ function localFileFailure(err: unknown): string {
   return `Failed to read file: ${err instanceof Error ? err.message : String(err)}`;
 }
 
+const HTML_FILE_EXTENSIONS = new Set([".htm", ".html", ".xht", ".xhtml"]);
+
+function localFileContentType(filePath: string): string {
+  const dot = filePath.lastIndexOf(".");
+  return dot !== -1 && HTML_FILE_EXTENSIONS.has(filePath.slice(dot).toLowerCase()) ? "text/html" : "";
+}
+
 async function readLocalFile(
   filePath: string,
   options: { signal?: AbortSignal; maxChars?: number; maxBytes?: number; maxPdfBytes?: number },
@@ -1333,16 +1450,16 @@ async function readLocalFile(
     }
     const text = decodeWithCodec(body, bomCodecFor(body) ?? "utf-8");
     if (looksBinary(text)) return `(binary content, ${body.length} bytes; not readable as text)`;
-    return truncatePageText(withTruncation(renderBody(text, ""), truncated), options.maxChars);
+    return truncatePageText(withTruncation(renderBody(text, localFileContentType(filePath)), truncated), options.maxChars);
   } finally {
     await handle.close().catch(() => {});
   }
 }
 
-export async function fetchPageText(
+export async function fetchPageOutcome(
   url: string,
   options: FetchPageOptions = {},
-): Promise<string> {
+): Promise<FetchPageOutcome> {
   const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
   const now = options.nowMs ?? Date.now;
   const deadlineMs = options.deadlineMs ?? now() + timeoutMs;
@@ -1353,18 +1470,19 @@ export async function fetchPageText(
   if (options.allowLocalFiles !== false) {
     const localPath = parseLocalPath(url);
     if (localPath !== null) {
-      if (!localPath) return "Failed to read file: invalid file URL.";
-      return readLocalFile(localPath, {
+      if (!localPath) return { text: "Failed to read file: invalid file URL.", hint: null };
+      const localText = await readLocalFile(localPath, {
         signal,
         maxChars,
         maxBytes: options.maxBytes,
         maxPdfBytes: options.maxPdfBytes,
       });
+      return { text: localText, hint: null };
     }
   }
   url = normalizeUrlScheme(url);
   const [allowed, reason] = checkUrlAccess(url, policy);
-  if (!allowed) return reason;
+  if (!allowed) return { text: reason, hint: null };
   const rawFetchOptions = {
     deadlineMs,
     signal,
@@ -1373,6 +1491,7 @@ export async function fetchPageText(
     maxBytes: options.maxBytes,
     maxPdfBytes: options.maxPdfBytes,
     seams: options.seams,
+    transport: options.transport,
   };
   const useCache = !options.seams && !options.rawFetch;
   const githubRaw = githubRawContentUrl(url);
@@ -1381,7 +1500,7 @@ export async function fetchPageText(
     if (rawResult.error === null) {
       const out = renderBody(rawResult.body, rawResult.contentType);
       await persistCache(url, rawResult.body, rawResult.contentType, useCache);
-      return truncatePageText(out, maxChars);
+      return { text: truncatePageText(out, maxChars), hint: null };
     }
   }
   const readmeApiUrl = githubRepoReadmeApiUrl(url);
@@ -1397,7 +1516,7 @@ export async function fetchPageText(
     if (apiBody.trim()) {
       const rendered = `README of ${url} (fetched via the GitHub README API):\n\n` + apiBody;
       await persistCache(url, rendered, "text/markdown", useCache);
-      return truncatePageText(rendered, maxChars);
+      return { text: truncatePageText(rendered, maxChars), hint: null };
     }
     const rawReadmeUrl = githubRepoRawReadmeUrl(url);
     if (rawReadmeUrl) {
@@ -1406,7 +1525,7 @@ export async function fetchPageText(
       if (rawBody.trim()) {
         const rendered = `README of ${url} (fetched via the GitHub raw README URL):\n\n` + rawBody;
         await persistCache(url, rendered, "text/markdown", useCache);
-        return truncatePageText(rendered, maxChars);
+        return { text: truncatePageText(rendered, maxChars), hint: null };
       }
     }
   }
@@ -1421,7 +1540,7 @@ export async function fetchPageText(
             let cachedOut = renderBody(cached.body, cached.contentType);
             if (!isFresh(cached, now())) cachedOut += staleNotice(cached);
             else cachedOut += "\n\n*Served from cache — network fetch failed*";
-            return truncatePageText(cachedOut, maxChars);
+            return { text: truncatePageText(cachedOut, maxChars), hint: null };
           }
         } catch {}
       }
@@ -1433,14 +1552,19 @@ export async function fetchPageText(
             const ts = wb.timestamp ? `${wb.timestamp.slice(0, 4)}-${wb.timestamp.slice(4, 6)}-${wb.timestamp.slice(6, 8)}` : "unknown date";
             out = `*Fetched from Wayback Machine snapshot (${ts}) for ${originalUrl}:*\n\n` + out;
             await persistCache(originalUrl, wb.body, wb.contentType, useCache);
-            return truncatePageText(out, maxChars);
+            return { text: truncatePageText(out, maxChars), hint: null };
           }
         } catch {}
       }
     }
-    return result.error;
+    return { text: result.error, hint: null };
   }
   const finalOut = renderBody(result.body, result.contentType);
+  const hint = isHtmlContent(result.body, result.contentType) ? needsRenderHint(result.body, finalOut) : null;
   await persistCache(originalUrl, result.body, result.contentType, useCache);
-  return truncatePageText(finalOut, maxChars);
+  return { text: truncatePageText(finalOut, maxChars), hint };
+}
+
+export async function fetchPageText(url: string, options: FetchPageOptions = {}): Promise<string> {
+  return (await fetchPageOutcome(url, options)).text;
 }

package/config-ui.ts

@@ -1,105 +0,0 @@
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
-import { readConfig, type Config } from "./config.ts";
-
-export type ConfigToggleKey = "webRenderEnabled";
-
-export interface ConfigRow {
-  key: ConfigToggleKey;
-  label: string;
-  hint: string;
-  enabled: boolean;
-}
-
-export function configRows(config: Config): ConfigRow[] {
-  return [
-    {
-      key: "webRenderEnabled",
-      label: "Web render",
-      hint: "web_render tool (Jina Reader)",
-      enabled: config.webRenderEnabled !== false,
-    },
-  ];
-}
-
-function padRow(theme: Theme, innerWidth: number, content: string): string {
-  const padded = content + " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
-  return theme.fg("border", "│") + padded + theme.fg("border", "│");
-}
-
-export class WebToolsConfigOverlay {
-  private rows: ConfigRow[] = [];
-  private selected = 0;
-
-  constructor(
-    private readonly opts: {
-      tui: { requestRender(force?: boolean): void };
-      theme: Theme;
-      done: () => void;
-      onToggle: (key: ConfigToggleKey) => Promise<void>;
-    },
-  ) {}
-
-  async load(): Promise<void> {
-    this.rows = configRows(await readConfig());
-  }
-
-  private runToggle(row: ConfigRow): void {
-    this.opts.tui.requestRender(true);
-    void this.opts
-      .onToggle(row.key)
-      .then(async () => {
-        this.rows = configRows(await readConfig());
-        this.opts.tui.requestRender(true);
-      })
-      .catch((error: unknown) => {
-        console.error("Failed to toggle web tools setting:", error);
-      });
-  }
-
-  private toggleSelected(): void {
-    const row = this.rows[this.selected];
-    if (!row) return;
-    row.enabled = !row.enabled;
-    this.runToggle(row);
-  }
-
-  handleInput(data: string): void {
-    if (matchesKey(data, Key.up) || data === "k") {
-      this.selected = (this.selected + this.rows.length - 1) % this.rows.length;
-      return;
-    }
-    if (matchesKey(data, Key.down) || data === "j") {
-      this.selected = (this.selected + 1) % this.rows.length;
-      return;
-    }
-    if (matchesKey(data, Key.space) || matchesKey(data, Key.enter) || data === " " || data === "\r" || data === "\n") {
-      this.toggleSelected();
-      return;
-    }
-    if (matchesKey(data, Key.escape) || data === "q") {
-      this.opts.done();
-    }
-  }
-
-  invalidate(): void {}
-
-  render(width: number): string[] {
-    const theme = this.opts.theme;
-    const innerWidth = width - 2;
-    const lines: string[] = [];
-    lines.push(theme.fg("border", `╭${"─".repeat(innerWidth)}╮`));
-    lines.push(padRow(theme, innerWidth, ` ${theme.fg("accent", theme.bold("Web Tools Config"))}`));
-    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    this.rows.forEach((row, index) => {
-      const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
-      const box = row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
-      const label = index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
-      lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", `— ${row.hint}`)}`));
-    });
-    lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · q close")));
-    lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
-    return lines;
-  }
-}