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

0 downloads

dbbasic-browser/apps/browser/src/history-copy.ts
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
history-copy.ts · 7.3 KB · 210 lines
1/**
2 * A copy of your askrobots history on this machine, so the address bar can suggest pages you visited, on any of your
3 * computers, without sending what you type anywhere. Electron-free (main.ts gives it the connection and a file), so it is
4 * unit-tested.
5 *
6 * - Only addresses, titles and times: never the pages' text.
7 * - Kept up to date with the account's list_history: each answer gives a cursor for the next read, the visits added since
8 * and the ids of visits forgotten since (on any computer). "full_copy" means start again from nothing.
9 * - Signing out, or signing in again (perhaps as someone else), deletes it.
10 * - At most MAX_VISITS visits; the oldest go first.
11 */
12
13export const MAX_VISITS = 20_000;
14const PAGE = 500;
15/** Pages read in one go; the rest come on the next read. */
16const MAX_PAGES = 40;
17
18export interface CopyVisit {
19 id: string;
20 url: string;
21 title: string;
22 /** When it was visited, in ms. */
23 at: number;
24}
25
26/** A page, all its visits together: what the address bar suggests. */
27export interface HistoryPage {
28 url: string;
29 title: string;
30 visits: number;
31 last: number;
32}
33
34export interface HistoryCopyDeps {
35 call(tool: string, args: Record<string, unknown>): Promise<string>;
36 /** Signed in, with the history permission. */
37 connected(): boolean;
38 /** The saved copy, or null. */
39 load(): string | null;
40 /** Save the copy; null deletes it. */
41 save(text: string | null): void;
42 now(): number;
43}
44
45interface Saved {
46 v: 1;
47 cursor?: string;
48 visits: CopyVisit[];
49}
50
51export class HistoryCopy {
52 private visits = new Map<string, CopyVisit>();
53 private cursor: string | undefined;
54 private loaded = false;
55 private syncing: Promise<void> | null = null;
56 private pagesCache: HistoryPage[] | null = null;
57 private pagesAt = 0;
58 private lastError: string | undefined;
59 private lastSync: number | undefined;
60
61 constructor(private d: HistoryCopyDeps) {}
62
63 private ensureLoaded(): void {
64 if (this.loaded) return;
65 this.loaded = true;
66 try {
67 const raw = this.d.load();
68 if (!raw) return;
69 const s = JSON.parse(raw) as Saved;
70 if (s.v !== 1 || !Array.isArray(s.visits)) return;
71 for (const v of s.visits) if (v && typeof v.id === "string" && typeof v.url === "string" && typeof v.at === "number") this.visits.set(v.id, { id: v.id, url: v.url, title: String(v.title ?? ""), at: v.at });
72 this.cursor = typeof s.cursor === "string" ? s.cursor : undefined;
73 } catch {
74 this.visits.clear();
75 this.cursor = undefined;
76 }
77 }
78
79 private persist(): void {
80 const s: Saved = { v: 1, ...(this.cursor ? { cursor: this.cursor } : {}), visits: [...this.visits.values()] };
81 this.d.save(JSON.stringify(s));
82 }
83
84 state(): { visits: number; pages: number; lastSync?: number; error?: string } {
85 this.ensureLoaded();
86 return { visits: this.visits.size, pages: this.pages().length, ...(this.lastSync ? { lastSync: this.lastSync } : {}), ...(this.lastError ? { error: this.lastError } : {}) };
87 }
88
89 /** Signed out, or signed in again: the copy belongs to the account it came from, so it goes. */
90 clear(): void {
91 this.loaded = true;
92 this.visits.clear();
93 this.cursor = undefined;
94 this.pagesCache = null;
95 this.lastError = undefined;
96 this.lastSync = undefined;
97 this.d.save(null);
98 }
99
100 /** Take visits out here at once (a forget), before the account's list says so too. */
101 remove(gone: (v: CopyVisit) => boolean): void {
102 this.ensureLoaded();
103 let any = false;
104 for (const [id, v] of this.visits) if (gone(v)) (this.visits.delete(id), (any = true));
105 if (any) {
106 this.pagesCache = null;
107 this.persist();
108 }
109 }
110
111 /** Read what changed on the account since the last read. One at a time; a second call waits for the first. */
112 sync(): Promise<void> {
113 if (this.syncing) return this.syncing;
114 this.syncing = this.pull().finally(() => {
115 this.syncing = null;
116 });
117 return this.syncing;
118 }
119
120 private async pull(): Promise<void> {
121 this.ensureLoaded();
122 if (!this.d.connected()) return;
123 let restarted = false;
124 let changed = false;
125 try {
126 for (let page = 0; page < MAX_PAGES; page++) {
127 const res = JSON.parse(await this.d.call("list_history", { ...(this.cursor ? { cursor: this.cursor } : {}), limit: PAGE })) as {
128 visits?: Array<{ id?: unknown; url?: unknown; title?: unknown; visited_at?: unknown }>;
129 forgotten?: unknown[];
130 full_copy?: boolean;
131 cursor?: unknown;
132 has_more?: boolean;
133 error?: unknown;
134 };
135 if (res.error) {
136 // a cursor the account no longer knows: start again from nothing, once
137 if (this.cursor && !restarted) {
138 restarted = true;
139 this.visits.clear();
140 this.cursor = undefined;
141 changed = true;
142 page = -1;
143 continue;
144 }
145 throw new Error(String(res.error));
146 }
147 if (res.full_copy && this.cursor && !restarted) {
148 restarted = true;
149 this.visits.clear();
150 this.cursor = undefined;
151 changed = true;
152 page = -1;
153 continue;
154 }
155 for (const id of res.forgotten ?? []) if (this.visits.delete(String(id))) changed = true;
156 for (const v of res.visits ?? []) {
157 if (typeof v.id !== "string" && typeof v.id !== "number") continue;
158 if (typeof v.url !== "string") continue;
159 const at = Date.parse(String(v.visited_at ?? ""));
160 this.visits.set(String(v.id), { id: String(v.id), url: v.url, title: typeof v.title === "string" ? v.title.slice(0, 300) : "", at: Number.isFinite(at) ? at : 0 });
161 changed = true;
162 }
163 if (typeof res.cursor === "string") this.cursor = res.cursor;
164 if (!res.has_more) break;
165 }
166 this.lastError = undefined;
167 this.lastSync = this.d.now();
168 } catch (e) {
169 this.lastError = e instanceof Error ? e.message.slice(0, 200) : String(e);
170 }
171 if (this.visits.size > MAX_VISITS) {
172 const oldest = [...this.visits.values()].sort((a, b) => a.at - b.at).slice(0, this.visits.size - MAX_VISITS);
173 for (const v of oldest) this.visits.delete(v.id);
174 changed = true;
175 }
176 if (changed) {
177 this.pagesCache = null;
178 this.persist();
179 } else if (this.cursor) this.persist();
180 }
181
182 /**
183 * Every page, the ones you visit most and most lately first: how often (up to 20 visits counted), weighted by how long ago
184 * the last visit was.
185 */
186 pages(): HistoryPage[] {
187 this.ensureLoaded();
188 if (this.pagesCache && this.d.now() - this.pagesAt < 60_000) return this.pagesCache;
189 const by = new Map<string, HistoryPage>();
190 for (const v of this.visits.values()) {
191 const p = by.get(v.url);
192 if (!p) by.set(v.url, { url: v.url, title: v.title, visits: 1, last: v.at });
193 else {
194 p.visits++;
195 if (v.at >= p.last) {
196 p.last = v.at;
197 if (v.title) p.title = v.title;
198 } else if (!p.title && v.title) p.title = v.title;
199 }
200 }
201 const now = this.d.now();
202 const weight = (p: HistoryPage) => {
203 const days = (now - p.last) / 86_400_000;
204 return Math.min(p.visits, 20) * (days < 1 ? 4 : days < 7 ? 2 : days < 30 ? 1 : 0.5);
205 };
206 this.pagesAt = now;
207 this.pagesCache = [...by.values()].sort((a, b) => weight(b) - weight(a) || b.last - a.last);
208 return this.pagesCache;
209 }
210}