sailfork / t3code-github / packages/ shared/ src/ preview.ts

import type { BrowserSearchEngine } from "@t3tools/contracts";
import * as Schema from "effect/Schema";

import { isLocalLoopbackHost } from "./hostClassification.ts";

const TAB_ID_PREFIX = "tab_";
let nextPreviewTabSequence = 0;

export function previewPdfAssetUrl(rawUrl: string, httpBaseUrl: string | null): string | null {
  if (httpBaseUrl === null) return null;
  try {
    const url = new URL(rawUrl);
    const baseUrl = new URL(httpBaseUrl);
    if (
      (url.protocol !== "http:" && url.protocol !== "https:") ||
      !url.pathname.startsWith("/api/assets/") ||
      !/\.pdf$/i.test(url.pathname)
    ) {
      return null;
    }
    if (
      url.origin !== baseUrl.origin &&
      !isLocalLoopbackHost(url.hostname) &&
      url.hostname !== "0.0.0.0"
    ) {
      return url.href;
    }
    // The browser may run on the host's loopback address. Fetch signed bytes
    // through this client's environment connection, including remote routes.
    return new URL(`${url.pathname}${url.search}${url.hash}`, baseUrl).href;
  } catch {
    return null;
  }
}

export function newPreviewTabId(): string {
  nextPreviewTabSequence += 1;
  return `${TAB_ID_PREFIX}${nextPreviewTabSequence.toString(36)}`;
}

const LOOPBACK_HOSTS: ReadonlySet<string> = new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1"]);

export const LSOF_LOCAL_HOST_TOKENS: ReadonlySet<string> = new Set([
  ...LOOPBACK_HOSTS,
  "*",
  "[::]",
  "[::1]",
]);

const LOOPBACK_PREFIX_PATTERN = /^(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\])(?::|\/|$)/i;

export function isLoopbackHost(host: string): boolean {
  if (LOOPBACK_HOSTS.has(host)) return true;
  if (host === "[::1]") return true;
  return false;
}

export class PreviewUrlNormalizationError extends Schema.TaggedError<PreviewUrlNormalizationError>()(
  "PreviewUrlNormalizationError",
  {
    inputLength: Schema.Number,
    reason: Schema.Literals(["empty", "parse", "unsupported-protocol"]),
    protocol: Schema.optional(Schema.String),
    cause: Schema.optional(Schema.Defect()),
  },
) {
  override get message(): string {
    const protocol = this.protocol === undefined ? "" : `: ${this.protocol}`;
    return `Invalid preview URL (${this.reason}${protocol}; input length ${this.inputLength}). Use an http(s) URL or a schemeless host such as localhost:5173. With preview_open, omit url when creating a new tab to open a blank tab.`;
  }
}

export const isPreviewUrlNormalizationError = Schema.is(PreviewUrlNormalizationError);

function previewUrlProtocol(rawUrl: string): string | undefined {
  return /^([A-Za-z][A-Za-z\d+.-]*):/.exec(rawUrl)?.[1]?.toLowerCase().concat(":");
}

const ADDRESS_HOST_PATTERN = /^(?:localhost|\d{1,3}(?:\.\d{1,3}){3}|\[[\da-f:.]+\])$/i;
const BARE_HOST_PORT_PATTERN = /^[^/?#:@]+:\d+(?:[/?#]|$)/;
const URL_SCHEME_WITH_AUTHORITY_PATTERN = /^[a-z][a-z\d+.-]*:\/\//i;
const KNOWN_NON_WEB_SCHEMES: ReadonlySet<string> = new Set([
  "about:",
  "blob:",
  "chrome:",
  "data:",
  "file:",
  "ftp:",
  "javascript:",
  "mailto:",
  "sms:",
  "ssh:",
  "tel:",
  "view-source:",
  "ws:",
  "wss:",
]);

/** Address bar search URL templates; `%s` is replaced with the encoded query. */
const BROWSER_SEARCH_URL_TEMPLATES = {
  duckduckgo: "https://duckduckgo.com/?q=%s",
  google: "https://www.google.com/search?q=%s",
  bing: "https://www.bing.com/search?q=%s",
  brave: "https://search.brave.com/search?q=%s",
  kagi: "https://kagi.com/search?q=%s",
  ecosia: "https://www.ecosia.org/search?q=%s",
} satisfies Record<Exclude<BrowserSearchEngine, "custom">, string>;

function fillSearchUrlTemplate(template: string, query: string): string {
  return template.replaceAll("%s", encodeURIComponent(query));
}

/**
 * Whether a custom search URL is an http(s) URL with `%s` where the query goes.
 * `%s` in the host or credentials is rejected: the query would never reach a
 * search page, and a query with spaces would make the host unreachable.
 */
export function isValidSearchUrlTemplate(template: string): boolean {
  if (!template.includes("%s")) return false;
  try {
    // Two queries land on different authorities only when `%s` sits before the path.
    const authority = (url: URL) => `${url.username}:${url.password}@${url.host}`;
    const url = new URL(fillSearchUrlTemplate(template, "a"));
    const other = new URL(fillSearchUrlTemplate(template, "b"));
    return (
      (url.protocol === "http:" || url.protocol === "https:") && authority(url) === authority(other)
    );
  } catch {
    return false;
  }
}

/**
 * The search URL template for the chosen engine. An unusable custom template
 * falls back to DuckDuckGo so a query typed in the address bar always searches.
 */
export function resolveSearchUrlTemplate(settings: {
  readonly browserSearchEngine: BrowserSearchEngine;
  readonly browserCustomSearchUrl: string;
}): string {
  if (settings.browserSearchEngine !== "custom") {
    return BROWSER_SEARCH_URL_TEMPLATES[settings.browserSearchEngine];
  }
  const custom = settings.browserCustomSearchUrl.trim();
  return isValidSearchUrlTemplate(custom) ? custom : BROWSER_SEARCH_URL_TEMPLATES.duckduckgo;
}

export function resolveAddressBarInput(
  rawInput: string,
  searchUrlTemplate: string = BROWSER_SEARCH_URL_TEMPLATES.duckduckgo,
): string {
  const trimmed = rawInput.trim();
  if (URL_SCHEME_WITH_AUTHORITY_PATTERN.test(trimmed) || trimmed.length === 0)
    return normalizePreviewUrl(trimmed);
  if (!/\s/.test(trimmed)) {
    // Reject explicit schemes before URL normalization can misread mailto as bare-host credentials.
    const protocol = previewUrlProtocol(trimmed);
    if (
      protocol !== undefined &&
      (KNOWN_NON_WEB_SCHEMES.has(protocol) || !BARE_HOST_PORT_PATTERN.test(trimmed))
    ) {
      if (protocol !== "http:" && protocol !== "https:") {
        throw new PreviewUrlNormalizationError({
          inputLength: rawInput.length,
          reason: "unsupported-protocol",
          protocol,
        });
      }
      return normalizePreviewUrl(trimmed);
    }
    const authority = trimmed.split(/[/?#]/, 1)[0] ?? "";
    const host = authority.replace(/^[^@]*@/, "").replace(/:\d+$/, "");
    const hasPort = host.length < authority.replace(/^[^@]*@/, "").length;
    if (hasPort || ADDRESS_HOST_PATTERN.test(host) || /^[^.]+(?:\.[^.]+)+\.?$/.test(host)) {
      try {
        return normalizePreviewUrl(trimmed);
      } catch {}
    }
  }
  return fillSearchUrlTemplate(searchUrlTemplate, trimmed);
}

export function normalizePreviewUrl(rawUrl: string): string {
  const trimmed = rawUrl.trim();
  if (trimmed.length === 0) {
    throw new PreviewUrlNormalizationError({ inputLength: rawUrl.length, reason: "empty" });
  }
  const explicitProtocol = previewUrlProtocol(trimmed);
  if (explicitProtocol !== undefined && KNOWN_NON_WEB_SCHEMES.has(explicitProtocol)) {
    throw new PreviewUrlNormalizationError({
      inputLength: rawUrl.length,
      reason: "unsupported-protocol",
      protocol: explicitProtocol,
    });
  }
  const useHttp = LOOPBACK_PREFIX_PATTERN.test(trimmed);
  const candidate = URL_SCHEME_WITH_AUTHORITY_PATTERN.test(trimmed)
    ? trimmed
    : `${useHttp ? "http" : "https"}://${trimmed}`;
  let parsed: URL;
  try {
    parsed = new URL(candidate);
  } catch (cause) {
    throw new PreviewUrlNormalizationError({
      inputLength: rawUrl.length,
      reason: "parse",
      protocol: previewUrlProtocol(candidate),
      cause,
    });
  }
  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
    throw new PreviewUrlNormalizationError({
      inputLength: rawUrl.length,
      reason: "unsupported-protocol",
      protocol: parsed.protocol,
    });
  }
  return parsed.href;
}