A desktop browser with x402 built in: when a page asks for payment, it pays in stablecoins and shows the content.

0 downloads

Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-browser.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-browser.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-browser.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 site icons (favicons) in tabs, address bar suggestions and the bookmarks panel 7249579 15 hours, 50 minutes ago History
favicons.ts · 6.5 KB · 137 lines
1// Site icons (favicons), one per host, for the tabs, the address bar's suggestions and the bookmarks panel.
2//
3// A page names its icon; the browser fetches it once (through the page's own session, like any of its requests), shrinks
4// it when it can, and keeps it here as a data: URL. The chrome UI only ever shows these data: URLs, so it never loads
5// anything from a site itself. Icons are learned only from pages you open: typing in the address bar fetches nothing, so a
6// page from your history that was never opened on this computer shows the row's usual symbol instead.
7// The file is a list of sites you have opened, so it is readable only by you, and forgetting a site forgets its icon.
8
9export const MAX_HOSTS = 1500;
10export const MAX_BYTES = 48 * 1024; // an icon bigger than this (after shrinking) is not kept
11export const REFRESH_MS = 7 * 24 * 3600 * 1000; // look again for a site's icon after a week
12const RETRY_MS = 24 * 3600 * 1000; // a site whose icon could not be fetched is not tried again for a day
13
14export interface Fetched { bytes: Uint8Array; type: string }
15export interface FaviconDeps {
16 /** Fetch an icon's bytes, or null (network error, not an image, too big). */
17 fetch(url: string): Promise<Fetched | null>;
18 /** Shrink to a 32×32 PNG data: URL when the format allows it (PNG, JPEG); null to keep the original. */
19 shrink(f: Fetched): string | null;
20 load(): string | null;
21 save(text: string | null): void;
22 now(): number;
23}
24interface Entry { icon: string; at: number; seen: number }
25
26const IMAGE = /^image\/(png|x-icon|vnd\.microsoft\.icon|ico|svg\+xml|jpeg|gif|webp|bmp)$/i;
27
28/** The image type from the first bytes (servers often send icons as text/plain or octet-stream), or null. */
29export function sniff(b: Uint8Array): string | null {
30 const at = (i: number, ...xs: number[]) => xs.every((x, j) => b[i + j] === x);
31 if (at(0, 0x89, 0x50, 0x4e, 0x47)) return "image/png";
32 if (at(0, 0x00, 0x00, 0x01, 0x00)) return "image/x-icon";
33 if (at(0, 0xff, 0xd8, 0xff)) return "image/jpeg";
34 if (at(0, 0x47, 0x49, 0x46, 0x38)) return "image/gif";
35 if (at(0, 0x52, 0x49, 0x46, 0x46) && at(8, 0x57, 0x45, 0x42, 0x50)) return "image/webp";
36 const head = Buffer.from(b.subarray(0, 512)).toString("utf8").trimStart().toLowerCase();
37 if (/^(<\?xml[^>]*>\s*)?(<!--[\s\S]*?-->\s*)*<svg[\s>]/.test(head)) return "image/svg+xml";
38 if (/^<(!doctype|html)/.test(head)) return "text/html"; // a "not found" page served as the icon
39 return null;
40}
41
42export function hostOf(url: string): string {
43 try {
44 const u = new URL(url);
45 return /^https?:$/.test(u.protocol) ? u.hostname.toLowerCase() : "";
46 } catch { return ""; }
47}
48
49export class FaviconStore {
50 private map = new Map<string, Entry>();
51 private failed = new Map<string, number>(); // host -> when it last failed (not saved)
52 private busy = new Set<string>();
53 private saveTimer: ReturnType<typeof setTimeout> | null = null;
54
55 constructor(private deps: FaviconDeps) {
56 try {
57 const raw = deps.load();
58 const obj = raw ? JSON.parse(raw) : null;
59 if (obj && obj.v === 1 && obj.icons && typeof obj.icons === "object") {
60 for (const [h, e] of Object.entries(obj.icons as Record<string, Entry>)) {
61 if (e && typeof e.icon === "string" && e.icon.startsWith("data:image/") && typeof e.at === "number") this.map.set(h, { icon: e.icon, at: e.at, seen: Number(e.seen) || e.at });
62 }
63 }
64 } catch { /* a damaged file: start empty */ }
65 }
66
67 get(host: string): string | null { return this.map.get(host)?.icon ?? null; }
68 all(): Record<string, string> { return Object.fromEntries([...this.map].map(([h, e]) => [h, e.icon])); }
69 size(): number { return this.map.size; }
70
71 /**
72 * A page on `pageUrl` named these icons (best first). Fetches the first usable one unless the site's icon is fresh.
73 * Resolves to the new icon when it changed, else null.
74 */
75 async learn(pageUrl: string, candidates: string[]): Promise<string | null> {
76 const host = hostOf(pageUrl);
77 if (!host) return null;
78 const now = this.deps.now();
79 const had = this.map.get(host);
80 if (had) { had.seen = now; this.saveSoon(); }
81 if (had && now - had.at < REFRESH_MS) return null;
82 if ((this.failed.get(host) ?? -Infinity) > now - RETRY_MS || this.busy.has(host)) return null;
83 const url = candidates.find((c) => /^(https?:|data:image\/)/i.test(c));
84 if (!url) return null;
85 this.busy.add(host);
86 try {
87 const icon = await this.toDataUrl(url);
88 if (!icon) { this.failed.set(host, now); if (had) had.at = now; return null; }
89 this.map.set(host, { icon, at: now, seen: now });
90 this.trim();
91 this.saveSoon();
92 return had && had.icon === icon ? null : icon;
93 } finally { this.busy.delete(host); }
94 }
95
96 /** Forget one site's icon (forgetting the site from history), or every icon. */
97 forget(host?: string): void {
98 if (host === undefined) { this.map.clear(); this.failed.clear(); this.flush(); return; }
99 if (this.map.delete(host.toLowerCase())) this.flush();
100 }
101
102 flush(): void {
103 if (this.saveTimer) { clearTimeout(this.saveTimer); this.saveTimer = null; }
104 this.deps.save(this.map.size ? JSON.stringify({ v: 1, icons: Object.fromEntries(this.map) }) : null);
105 }
106
107 private saveSoon(): void {
108 if (this.saveTimer) return;
109 this.saveTimer = setTimeout(() => { this.saveTimer = null; this.flush(); }, 2000);
110 (this.saveTimer as { unref?: () => void }).unref?.();
111 }
112
113 private trim(): void {
114 if (this.map.size <= MAX_HOSTS) return;
115 const oldest = [...this.map].sort((a, b) => a[1].seen - b[1].seen).slice(0, this.map.size - MAX_HOSTS);
116 for (const [h] of oldest) this.map.delete(h);
117 }
118
119 private async toDataUrl(url: string): Promise<string | null> {
120 let f: Fetched | null;
121 if (/^data:/i.test(url)) {
122 const m = /^data:([^;,]+)(;base64)?,(.*)$/is.exec(url);
123 if (!m) return null;
124 const [, mime = "", b64, body = ""] = m;
125 let bytes: Uint8Array;
126 try { bytes = b64 ? Buffer.from(body, "base64") : Buffer.from(decodeURIComponent(body)); } catch { return null; }
127 f = { bytes, type: mime };
128 } else f = await this.deps.fetch(url);
129 if (!f || !f.bytes.length) return null;
130 const type = sniff(f.bytes) ?? (f.type.split(";")[0] ?? "").trim().toLowerCase();
131 if (!IMAGE.test(type)) return null;
132 f = { bytes: f.bytes, type };
133 const small = /png|jpeg/.test(type) ? this.deps.shrink(f) : null;
134 const out = small ?? `data:${type};base64,${Buffer.from(f.bytes).toString("base64")}`;
135 return out.length <= MAX_BYTES * 1.4 ? out : null;
136 }
137}