@gmickel/gno 1.27.1 → 1.29.0

package/src/converters/adapters/browser-export/adapter.ts

@@ -0,0 +1,199 @@
+import type {
+  RecordAdapter,
+  RecordAdapterEvent,
+  RecordAdapterInput,
+} from "../../types";
+
+import {
+  type BrowserExportRecord,
+  parseBrowserJson,
+  parseNetscapeBookmarks,
+} from "./formats";
+
+const LIVE_PROFILE_MARKERS = [
+  "/library/safari/",
+  "/chrome/user data/",
+  "/google/chrome/",
+  "/chromium/user data/",
+  "/.config/google-chrome/",
+  "/.config/chromium/",
+  "/appdata/local/google/chrome/user data/",
+  "/firefox/profiles/",
+  "/.mozilla/firefox/",
+  "/mozilla/firefox/",
+  "/appdata/roaming/mozilla/firefox/profiles/",
+];
+
+const safeMarkdown = (value: string): string =>
+  value
+    .normalize("NFC")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replace(/([\\`*_[\]#])/g, "\\$1")
+    .trim();
+
+const liveProfileReason = (input: RecordAdapterInput): string | undefined => {
+  const normalized = input.sourcePath.replaceAll("\\", "/").toLowerCase();
+  if (LIVE_PROFILE_MARKERS.some((marker) => normalized.includes(marker))) {
+    return "live-profile";
+  }
+  const basename = normalized.split("/").at(-1);
+  if (
+    basename === "cookies" ||
+    basename === "history" ||
+    basename?.endsWith(".sqlite") ||
+    basename?.endsWith(".db")
+  ) {
+    return "live-database";
+  }
+  return undefined;
+};
+
+const normalizeUrl = (value: string): string | undefined => {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return undefined;
+    }
+    if (url.username || url.password) return undefined;
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return undefined;
+  }
+};
+
+const readSource = async (input: RecordAdapterInput): Promise<string> => {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let source = "";
+  for await (const chunk of input.open()) {
+    source += decoder.decode(chunk, { stream: true });
+  }
+  return source + decoder.decode();
+};
+
+const recordEvent = (
+  record: BrowserExportRecord
+): RecordAdapterEvent | undefined => {
+  const url = normalizeUrl(record.url);
+  if (!url) return undefined;
+  const title = safeMarkdown(record.title || url);
+  const folder = record.folder ? safeMarkdown(record.folder) : undefined;
+  const tags = record.tags?.map(safeMarkdown).filter(Boolean);
+  const lines = [`# ${title}`, "", url];
+  if (folder) lines.push("", `Folder: ${folder}`);
+  if (tags && tags.length > 0) lines.push(`Tags: ${tags.join(", ")}`);
+  for (const [name, value] of Object.entries(record.dates ?? {}).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    lines.push(`${safeMarkdown(name)}: ${safeMarkdown(value)}`);
+  }
+  const identity = record.externalId
+    ? `${record.kind}:id:${record.externalId}`
+    : `${record.kind}:url:${url}`;
+  return {
+    type: "record",
+    record: {
+      stableId: `browser:${identity}`,
+      sourceLocator: record.sourceLocator,
+      markdown: lines.join("\n"),
+      title,
+      metadata: {
+        categories: ["browser-export", record.kind, ...(tags ?? [])],
+        dateFields: record.dates,
+      },
+      anchors: [{ kind: "record", value: record.sourceLocator }],
+    },
+  };
+};
+
+async function* parseBrowserExport(
+  input: RecordAdapterInput
+): AsyncGenerator<RecordAdapterEvent> {
+  const denied = liveProfileReason(input);
+  if (denied) {
+    yield {
+      type: "failure",
+      failure: {
+        code: "ADAPTER_FAILURE",
+        message: "Live browser profile access is not allowed.",
+        retryable: false,
+        sourceLocator: denied,
+      },
+    };
+    yield { type: "snapshot", state: "partial" };
+    return;
+  }
+
+  let source: string;
+  try {
+    source = await readSource(input);
+  } catch {
+    yield {
+      type: "failure",
+      failure: {
+        code: "MALFORMED_RECORD",
+        message: "Browser export could not be decoded.",
+        retryable: true,
+        sourceLocator: "export",
+      },
+    };
+    yield { type: "snapshot", state: "partial" };
+    return;
+  }
+  const trimmed = source.trimStart();
+  const parsed = trimmed.startsWith("<")
+    ? parseNetscapeBookmarks(
+        source,
+        input.limits.maxRecords,
+        input.limits.maxFailures
+      )
+    : parseBrowserJson(
+        source,
+        input.limits.maxRecords,
+        input.limits.maxFailures
+      );
+  let failures = parsed.failures.length;
+  for (const candidate of parsed.records) {
+    const event = recordEvent(candidate);
+    if (event) yield event;
+    else {
+      failures += 1;
+      yield {
+        type: "failure",
+        failure: {
+          code: "MALFORMED_RECORD",
+          message: "Browser export contained an invalid or unsafe URL.",
+          retryable: false,
+          sourceLocator: candidate.sourceLocator,
+        },
+      };
+    }
+  }
+  for (const locator of parsed.failures) {
+    yield {
+      type: "failure",
+      failure: {
+        code: "MALFORMED_RECORD",
+        message: "Browser export record could not be parsed.",
+        retryable: false,
+        sourceLocator: locator,
+      },
+    };
+  }
+  yield {
+    type: "snapshot",
+    state: failures === 0 ? "complete" : "partial",
+  };
+}
+
+export const browserExportAdapter: RecordAdapter = {
+  id: "adapter/browser-export",
+  version: "1.0.0",
+  canHandle: (mime, ext) =>
+    mime === "application/x-gno-browser-export+json" ||
+    mime === "text/x-gno-browser-bookmarks+html" ||
+    ext === ".browser-export",
+  records: parseBrowserExport,
+};

package/src/converters/adapters/browser-export/formats.ts

@@ -0,0 +1,358 @@
+import {
+  decodeHtmlEntitiesOnce,
+  htmlFragmentToText,
+} from "../shared/html-text";
+
+export type BrowserExportKind = "bookmark" | "history" | "reading-list";
+
+export interface BrowserExportRecord {
+  kind: BrowserExportKind;
+  url: string;
+  title?: string;
+  folder?: string;
+  tags?: string[];
+  dates?: Record<string, string>;
+  externalId?: string;
+  sourceLocator: string;
+}
+
+export interface BrowserExportParseResult {
+  records: BrowserExportRecord[];
+  failures: string[];
+}
+
+const HTML_TOKEN_PATTERN =
+  /<H3\b[^>]*>([\s\S]*?)<\/H3\s*>|<A\b([^>]*)>([\s\S]*?)<\/A\s*>|<DL\b[^>]*>|<\/DL\s*>/gi;
+const ATTRIBUTE_PATTERN = /([\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/g;
+const MAX_JSON_DEPTH = 32;
+const WEBKIT_TO_UNIX_EPOCH_MS = 11_644_473_600_000;
+const SENSITIVE_JSON_KEYS = new Set([
+  "cookies",
+  "passwords",
+  "logins",
+  "sessions",
+  "creditcards",
+]);
+const SUPPORTED_JSON_KEYS = new Set([
+  "roots",
+  "children",
+  "items",
+  "bookmarks",
+  "history",
+  "readingList",
+  "reading_list",
+]);
+const BOOKMARK_EXPORT_DOCUMENT_PATTERN =
+  /<!DOCTYPE\s+(?:NETSCAPE-Bookmark-file-1\b[^>]*|html\s*)>/i;
+
+const plainText = (value: string): string =>
+  htmlFragmentToText(value).replace(/\s+/g, " ").trim();
+
+const attributes = (value: string): Map<string, string> => {
+  const result = new Map<string, string>();
+  for (const match of value.matchAll(ATTRIBUTE_PATTERN)) {
+    const key = match[1]?.toLowerCase();
+    const item = match[2] ?? match[3] ?? match[4];
+    if (key && item !== undefined)
+      result.set(key, decodeHtmlEntitiesOnce(item));
+  }
+  return result;
+};
+
+const hasSensitiveJsonKey = (value: Record<string, unknown>): boolean =>
+  Object.keys(value).some((key) => SENSITIVE_JSON_KEYS.has(key.toLowerCase()));
+
+const tagCount = (source: string, pattern: RegExp): number =>
+  source.match(pattern)?.length ?? 0;
+
+const hasCompleteNetscapeStructure = (source: string): boolean => {
+  if (!BOOKMARK_EXPORT_DOCUMENT_PATTERN.test(source)) return false;
+  const openingDl = tagCount(source, /<DL\b[^>]*>/gi);
+  const closingDl = tagCount(source, /<\/DL\s*>/gi);
+  const openingAnchors = tagCount(source, /<A\b[^>]*>/gi);
+  const closingAnchors = tagCount(source, /<\/A\s*>/gi);
+  const openingHeadings = tagCount(source, /<H3\b[^>]*>/gi);
+  const closingHeadings = tagCount(source, /<\/H3\s*>/gi);
+  return (
+    openingDl > 0 &&
+    openingDl === closingDl &&
+    openingAnchors === closingAnchors &&
+    openingHeadings === closingHeadings
+  );
+};
+
+const exportDate = (value: string | undefined): string | undefined => {
+  if (!value) return undefined;
+  const epoch = Number(value);
+  if (Number.isFinite(epoch) && epoch >= 0) {
+    let milliseconds: number;
+    if (epoch >= 10_000_000_000_000_000) {
+      milliseconds = epoch / 1_000 - WEBKIT_TO_UNIX_EPOCH_MS;
+    } else {
+      milliseconds = epoch > 10_000_000_000 ? epoch : epoch * 1_000;
+    }
+    const date = new Date(milliseconds);
+    if (!Number.isNaN(date.getTime())) return date.toISOString();
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+  if (!/(?:Z|[+-]\d{2}:?\d{2})$/i.test(value)) return undefined;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+};
+
+export function parseNetscapeBookmarks(
+  source: string,
+  maxRecords: number,
+  maxFailures = 1_000
+): BrowserExportParseResult {
+  const records: BrowserExportRecord[] = [];
+  const failures: string[] = [];
+  const folders: string[] = [];
+  let pendingFolder: string | undefined;
+  let anchorNumber = 0;
+  let failureCapReached = false;
+  const addFailure = (locator: string): boolean => {
+    if (failureCapReached) return true;
+    if (failures.length < maxFailures) failures.push(locator);
+    if (failures.length < maxFailures) return false;
+    failures.push("failure-limit");
+    failureCapReached = true;
+    return failureCapReached;
+  };
+  if (!hasCompleteNetscapeStructure(source)) {
+    addFailure("unsupported-html");
+    return { records, failures };
+  }
+  let dlDepth = 0;
+  for (const token of source.matchAll(HTML_TOKEN_PATTERN)) {
+    const raw = token[0].toLowerCase();
+    if (token[1] !== undefined) {
+      pendingFolder = plainText(token[1]);
+      continue;
+    }
+    if (raw.startsWith("<dl")) {
+      dlDepth += 1;
+      if (pendingFolder) folders.push(pendingFolder);
+      pendingFolder = undefined;
+      continue;
+    }
+    if (raw.startsWith("</dl")) {
+      if (dlDepth === 0) {
+        addFailure("html-structure");
+        break;
+      }
+      dlDepth -= 1;
+      folders.pop();
+      continue;
+    }
+    if (token[2] === undefined || token[3] === undefined) continue;
+    anchorNumber += 1;
+    if (records.length >= maxRecords) {
+      addFailure(`bookmark:${anchorNumber}/record-limit`);
+      break;
+    }
+    const attrs = attributes(token[2]);
+    const url = attrs.get("href");
+    if (!url) {
+      if (addFailure(`bookmark:${anchorNumber}`)) break;
+      continue;
+    }
+    const rawAdded = attrs.get("add_date");
+    const rawModified = attrs.get("last_modified");
+    const added = exportDate(rawAdded);
+    const modified = exportDate(rawModified);
+    if ((rawAdded && !added) || (rawModified && !modified)) {
+      if (addFailure(`bookmark:${anchorNumber}/date`)) break;
+    }
+    records.push({
+      kind: "bookmark",
+      url,
+      title: plainText(token[3]),
+      folder: folders.join("/"),
+      tags: attrs
+        .get("tags")
+        ?.split(",")
+        .map((tag) => tag.trim())
+        .filter(Boolean),
+      dates:
+        added || modified
+          ? {
+              ...(added ? { added } : {}),
+              ...(modified ? { modified } : {}),
+            }
+          : undefined,
+      sourceLocator: `bookmark:${anchorNumber}`,
+    });
+  }
+  if (dlDepth !== 0 && !failureCapReached) addFailure("html-structure");
+  return { records, failures };
+}
+
+const stringValue = (
+  value: Record<string, unknown>,
+  keys: string[]
+): string | undefined => {
+  for (const key of keys) {
+    if (typeof value[key] === "string") return value[key] as string;
+    if (typeof value[key] === "number") return String(value[key]);
+  }
+  return undefined;
+};
+
+const kindValue = (value: Record<string, unknown>): BrowserExportKind => {
+  const raw = stringValue(value, ["kind", "type"])?.toLowerCase();
+  if (raw?.includes("history") || raw === "visit") return "history";
+  if (raw?.includes("reading") || raw === "read") return "reading-list";
+  return "bookmark";
+};
+
+const itemRecord = (
+  value: Record<string, unknown>,
+  locator: string,
+  folders: string[]
+): BrowserExportRecord | undefined => {
+  const url = stringValue(value, ["url", "href", "uri"]);
+  if (!url) return undefined;
+  const tags = Array.isArray(value.tags)
+    ? value.tags.filter((tag): tag is string => typeof tag === "string")
+    : typeof value.tags === "string"
+      ? value.tags.split(",").map((tag) => tag.trim())
+      : undefined;
+  const rawAdded = stringValue(value, ["date_added", "dateAdded", "added"]);
+  const rawVisited = stringValue(value, [
+    "last_visit_time",
+    "lastVisitTime",
+    "visited_at",
+  ]);
+  const rawRead = stringValue(value, ["read_at", "readAt"]);
+  const added = exportDate(rawAdded);
+  const visited = exportDate(rawVisited);
+  const read = exportDate(rawRead);
+  if ((rawAdded && !added) || (rawVisited && !visited) || (rawRead && !read)) {
+    return undefined;
+  }
+  const dateEntries: Array<[string, string]> = [];
+  if (added) dateEntries.push(["added", added]);
+  if (visited) dateEntries.push(["visited", visited]);
+  if (read) dateEntries.push(["read", read]);
+  return {
+    kind: kindValue(value),
+    url,
+    title: stringValue(value, ["name", "title"]),
+    folder: stringValue(value, ["folder", "path"]) ?? folders.join("/"),
+    tags,
+    dates: dateEntries.length > 0 ? Object.fromEntries(dateEntries) : undefined,
+    externalId: stringValue(value, ["id", "guid", "uuid"]),
+    sourceLocator: locator,
+  };
+};
+
+export function parseBrowserJson(
+  source: string,
+  maxRecords: number,
+  maxFailures = 1_000
+): BrowserExportParseResult {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    return { records: [], failures: ["json"] };
+  }
+  if (!Array.isArray(parsed) && (!parsed || typeof parsed !== "object")) {
+    return { records: [], failures: ["unsupported-json"] };
+  }
+  if (!Array.isArray(parsed)) {
+    const rootKeys = Object.keys(parsed as Record<string, unknown>);
+    if (hasSensitiveJsonKey(parsed as Record<string, unknown>)) {
+      return { records: [], failures: ["sensitive-json"] };
+    }
+    if (!rootKeys.some((key) => SUPPORTED_JSON_KEYS.has(key))) {
+      return { records: [], failures: ["unsupported-json"] };
+    }
+  }
+  const records: BrowserExportRecord[] = [];
+  const failures: string[] = [];
+  let capReached = false;
+  let failureCapReached = false;
+  const addFailure = (locator: string): boolean => {
+    if (failureCapReached) return true;
+    if (failures.length < maxFailures) failures.push(locator);
+    if (failures.length < maxFailures) return false;
+    failures.push("failure-limit");
+    failureCapReached = true;
+    capReached = true;
+    return true;
+  };
+  const stopAtCap = (locator: string): boolean => {
+    if (records.length < maxRecords) return false;
+    if (!capReached) addFailure(`${locator}/record-limit`);
+    capReached = true;
+    return true;
+  };
+  const visit = (
+    value: unknown,
+    locator: string,
+    folders: string[],
+    depth: number
+  ): void => {
+    if (capReached) return;
+    if (depth > MAX_JSON_DEPTH) {
+      addFailure(locator);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const [index, child] of value.entries()) {
+        if (stopAtCap(`${locator}/${index}`)) break;
+        visit(child, `${locator}/${index}`, folders, depth + 1);
+      }
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    const object = value as Record<string, unknown>;
+    if (hasSensitiveJsonKey(object)) {
+      addFailure(`${locator}/sensitive`);
+      return;
+    }
+    const record = itemRecord(object, locator, folders);
+    if (record) {
+      if (stopAtCap(locator)) return;
+      records.push(record);
+    }
+    const folderName =
+      !record && typeof object.name === "string" ? object.name : undefined;
+    const nextFolders = folderName ? [...folders, folderName] : folders;
+    const supportedChildren = [...SUPPORTED_JSON_KEYS].filter((key) =>
+      Object.hasOwn(object, key)
+    );
+    if (!record && supportedChildren.length === 0) {
+      addFailure(locator);
+      return;
+    }
+    for (const key of supportedChildren) {
+      const child = object[key];
+      const validRoots =
+        key === "roots" &&
+        child !== null &&
+        typeof child === "object" &&
+        !Array.isArray(child);
+      const validItems = key !== "roots" && Array.isArray(child);
+      if (!(validRoots || validItems)) {
+        if (addFailure(`${locator}/${key}`)) break;
+        continue;
+      }
+      if (validRoots) {
+        for (const [rootName, root] of Object.entries(
+          child as Record<string, unknown>
+        )) {
+          if (capReached) break;
+          visit(root, `${locator}/roots/${rootName}`, nextFolders, depth + 1);
+        }
+      } else {
+        visit(child, `${locator}/${key}`, nextFolders, depth + 1);
+      }
+      if (capReached) break;
+    }
+  };
+  visit(parsed, "json", [], 0);
+  return { records, failures };
+}