refactor: remove turborepo

2024-08-12 09:07:11 +07:00
parent e2103ae23a
commit da8162069b
312 changed files with 1473 additions and 4514 deletions
--- a/src/system/account.ts
+++ b/src/system/account.ts
@@ -0,0 +1,167 @@
+import { type Result, commands } from "@/commands.gen";
+import type { Metadata } from "@/types";
+
+export const NostrAccount = {
+	getAccounts: async () => {
+		const query = await commands.getAccounts();
+		return query;
+	},
+	loadAccount: async (npub: string) => {
+		const bunker: string = localStorage.getItem(`${npub}_bunker`);
+		let query: Result<boolean, string>;
+
+		if (bunker?.length && bunker?.startsWith("bunker://")) {
+			query = await commands.loadAccount(npub, bunker);
+		} else {
+			query = await commands.loadAccount(npub, null);
+		}
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	createAccount: async () => {
+		const query = await commands.createAccount();
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	createProfile: async (profile: Metadata) => {
+		const query = await commands.createProfile(
+			profile.name || "",
+			profile.display_name || "",
+			profile.about || "",
+			profile.picture || "",
+			profile.banner || "",
+			profile.nip05 || "",
+			profile.lud16 || "",
+			profile.website || "",
+		);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	saveAccount: async (nsec: string, password = "") => {
+		const query = await commands.saveAccount(nsec, password);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	connectRemoteAccount: async (uri: string) => {
+		const connect = await commands.connectRemoteAccount(uri);
+
+		if (connect.status === "ok") {
+			const npub = connect.data;
+			const parsed = new URL(uri);
+			parsed.searchParams.delete("secret");
+
+			// save connection string
+			localStorage.setItem(`${npub}_bunker`, parsed.toString());
+
+			return npub;
+		} else {
+			throw new Error(connect.error);
+		}
+	},
+	setContactList: async (pubkeys: string[]) => {
+		const query = await commands.setContactList(pubkeys);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	loadWallet: async () => {
+		const query = await commands.loadWallet();
+
+		if (query.status === "ok") {
+			return Number.parseInt(query.data);
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	setWallet: async (uri: string) => {
+		const query = await commands.setWallet(uri);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	removeWallet: async () => {
+		const query = await commands.removeWallet();
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	getProfile: async () => {
+		const query = await commands.getCurrentProfile();
+
+		if (query.status === "ok") {
+			return JSON.parse(query.data) as Metadata;
+		} else {
+			return null;
+		}
+	},
+	getContactList: async () => {
+		const query = await commands.getContactList();
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			return [];
+		}
+	},
+	isContactListEmpty: async () => {
+		const query = await commands.isContactListEmpty();
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			return true;
+		}
+	},
+	checkContact: async (pubkey: string) => {
+		const query = await commands.checkContact(pubkey);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	toggleContact: async (pubkey: string, alias?: string) => {
+		const query = await commands.toggleContact(pubkey, alias);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	f2f: async (npub: string) => {
+		const query = await commands.friendToFriend(npub);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+};
--- a/src/system/event.ts
+++ b/src/system/event.ts
@@ -0,0 +1,296 @@
+import { type Result, commands } from "@/commands.gen";
+import type { EventTag, Kind, Meta, NostrEvent } from "@/types";
+
+export class LumeEvent {
+	public id: string;
+	public pubkey: string;
+	public created_at: number;
+	public kind: Kind;
+	public tags: string[][];
+	public content: string;
+	public sig: string;
+	public meta: Meta;
+	public relay?: string;
+	public replies?: LumeEvent[];
+	#raw: NostrEvent;
+
+	constructor(event: NostrEvent) {
+		this.#raw = event;
+		Object.assign(this, event);
+	}
+
+	get isQuote() {
+		return this.tags.filter((tag) => tag[0] === "q").length > 0;
+	}
+
+	get isConversation() {
+		const tags = this.tags.filter(
+			(tag) => tag[0] === "e" && tag[3] !== "mention",
+		);
+		return tags.length > 0;
+	}
+
+	get mentions() {
+		return this.tags.filter((tag) => tag[0] === "p").map((tag) => tag[1]);
+	}
+
+	get repostId() {
+		return this.tags.find((tag) => tag[0] === "e")[1];
+	}
+
+	get thread() {
+		let root: EventTag = null;
+		let reply: EventTag = null;
+
+		// Get all event references from tags, ignore mention.
+		const events = this.tags.filter(
+			(el) => el[0] === "e" && el[3] !== "mention",
+		);
+
+		if (events.length === 1) {
+			root = { id: events[0][1], relayHint: events[0][2] };
+		}
+
+		if (events.length === 2) {
+			root = { id: events[0][1], relayHint: events[0][2] };
+			reply = { id: events[1][1], relayHint: events[1][2] };
+		}
+
+		if (events.length > 2) {
+			for (const tag of events) {
+				if (tag[3] === "root") root = { id: tag[1], relayHint: tag[2] };
+				if (tag[3] === "reply") reply = { id: tag[1], relayHint: tag[2] };
+			}
+		}
+
+		// Fix some rare case when root same as reply
+		if (root && reply && root.id === reply.id) {
+			reply = null;
+		}
+
+		return {
+			root,
+			reply,
+		};
+	}
+
+	get quote() {
+		const tag = this.tags.filter(
+			(tag) => tag[0] === "q" || tag[3] === "mention",
+		);
+		const id = tag[0][1];
+		const relayHint = tag[0][2];
+
+		return { id, relayHint };
+	}
+
+	get warning() {
+		const warningTag = this.tags.filter(
+			(tag) => tag[0] === "content-warning",
+		)?.[0];
+
+		if (warningTag) {
+			return warningTag[1];
+		} else {
+			const nsfwTag = this.tags.filter(
+				(tag) => tag[0] === "t" && tag[1] === "NSFW",
+			)?.[0];
+
+			if (nsfwTag) {
+				return "NSFW";
+			} else {
+				return null;
+			}
+		}
+	}
+
+	public async getEventReplies() {
+		const query = await commands.getReplies(this.id);
+
+		if (query.status === "ok") {
+			const events = query.data
+				// Create Lume Events
+				.map((item) => LumeEvent.from(item.raw, item.parsed))
+				// Filter quote event
+				.filter(
+					(ev) =>
+						!ev.tags.filter((t) => t[0] === "q" || t[3] === "mention").length,
+				);
+
+			if (events.length > 1) {
+				const removeQueues = new Set();
+
+				for (const event of events) {
+					const tags = event.tags.filter(
+						(t) => t[0] === "e" && t[1] !== this.id,
+					);
+
+					if (tags.length === 1) {
+						const index = events.findIndex((ev) => ev.id === tags[0][1]);
+
+						if (index !== -1) {
+							const rootEvent = events[index];
+
+							if (rootEvent.replies?.length) {
+								rootEvent.replies.push(event);
+							} else {
+								rootEvent.replies = [event];
+							}
+
+							// Add current event to queue
+							removeQueues.add(event.id);
+
+							continue;
+						}
+					}
+
+					for (const tag of tags) {
+						const id = tag[1];
+						const rootIndex = events.findIndex((ev) => ev.id === id);
+
+						if (rootIndex !== -1) {
+							const rootEvent = events[rootIndex];
+
+							if (rootEvent.replies?.length) {
+								const childIndex = rootEvent.replies.findIndex(
+									(ev) => ev.id === id,
+								);
+
+								if (childIndex !== -1) {
+									const childEvent = rootEvent.replies[rootIndex];
+
+									if (childEvent.replies?.length) {
+										childEvent.replies.push(event);
+									} else {
+										childEvent.replies = [event];
+									}
+
+									// Add current event to queue
+									removeQueues.add(event.id);
+								}
+							} else {
+								rootEvent.replies = [event];
+								// Add current event to queue
+								removeQueues.add(event.id);
+							}
+						}
+
+						break;
+					}
+				}
+
+				return events.filter((ev) => !removeQueues.has(ev.id));
+			}
+
+			return events;
+		} else {
+			console.error(query.error);
+			return [];
+		}
+	}
+
+	public async listenEventReply() {
+		const query = await commands.listenEventReply(this.id);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	public async unlistenEventReply() {
+		const query = await commands.unlisten(this.id);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	public async zap(amount: number, message: string) {
+		const query = await commands.zapEvent(this.id, amount.toString(), message);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	public async idAsBech32() {
+		const query = await commands.eventToBech32(this.id);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	public async pubkeyAsBech32() {
+		const query = await commands.userToBech32(this.pubkey);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	public async repost() {
+		const query = await commands.repost(JSON.stringify(this.#raw));
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	static async publish(
+		content: string,
+		warning?: string,
+		difficulty?: number,
+		reply_to?: string,
+		root_to?: string,
+	) {
+		let query: Result<string, string>;
+
+		if (reply_to) {
+			query = await commands.reply(content, reply_to, root_to);
+		} else {
+			query = await commands.publish(content, warning, difficulty);
+		}
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	}
+
+	static async build(event: NostrEvent) {
+		const query = await commands.getEventMeta(event.content);
+
+		if (query.status === "ok") {
+			event.meta = query.data;
+			return new LumeEvent(event);
+		} else {
+			return new LumeEvent(event);
+		}
+	}
+
+	static from(raw: string, parsed?: Meta) {
+		const nostrEvent: NostrEvent = JSON.parse(raw);
+
+		if (parsed) {
+			nostrEvent.meta = parsed;
+		} else {
+			nostrEvent.meta = null;
+		}
+
+		return new LumeEvent(nostrEvent);
+	}
+}
--- a/src/system/hooks/useEvent.ts
+++ b/src/system/hooks/useEvent.ts
@@ -0,0 +1,28 @@
+import { useQuery } from "@tanstack/react-query";
+import { NostrQuery } from "../query";
+import { experimental_createPersister } from "@tanstack/query-persist-client-core";
+
+export function useEvent(id: string, relayHint?: string) {
+	const { isLoading, isError, data } = useQuery({
+		queryKey: ["event", id],
+		queryFn: async () => {
+			try {
+				const event = await NostrQuery.getEvent(id, relayHint);
+				return event;
+			} catch (e) {
+				throw new Error(e);
+			}
+		},
+		refetchOnWindowFocus: false,
+		refetchOnMount: false,
+		refetchOnReconnect: false,
+		staleTime: Number.POSITIVE_INFINITY,
+		retry: 2,
+		persister: experimental_createPersister({
+			storage: localStorage,
+			maxAge: 1000 * 60 * 60 * 12, // 12 hours
+		}),
+	});
+
+	return { isLoading, isError, data };
+}
--- a/src/system/hooks/useProfile.ts
+++ b/src/system/hooks/useProfile.ts
@@ -0,0 +1,41 @@
+import { commands } from "@/commands.gen";
+import type { Metadata } from "@/types";
+import { experimental_createPersister } from "@tanstack/query-persist-client-core";
+import { useQuery } from "@tanstack/react-query";
+
+export function useProfile(pubkey: string, embed?: string) {
+	const {
+		isLoading,
+		isError,
+		data: profile,
+	} = useQuery({
+		queryKey: ["profile", pubkey],
+		queryFn: async () => {
+			try {
+				if (embed) return JSON.parse(embed) as Metadata;
+
+				const normalize = pubkey.replace("nostr:", "").replace(/[^\w\s]/gi, "");
+				const query = await commands.getProfile(normalize);
+
+				if (query.status === "ok") {
+					return JSON.parse(query.data) as Metadata;
+				} else {
+					throw new Error(query.error);
+				}
+			} catch (e) {
+				throw new Error(e);
+			}
+		},
+		refetchOnMount: false,
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+		staleTime: Number.POSITIVE_INFINITY,
+		retry: 2,
+		persister: experimental_createPersister({
+			storage: localStorage,
+			maxAge: 1000 * 60 * 60 * 24, // 24 hours
+		}),
+	});
+
+	return { isLoading, isError, profile };
+}
--- a/src/system/index.ts
+++ b/src/system/index.ts
@@ -0,0 +1,6 @@
+export * from "./event";
+export * from "./account";
+export * from "./query";
+export * from "./window";
+export * from "./hooks/useEvent";
+export * from "./hooks/useProfile";
--- a/src/system/query.ts
+++ b/src/system/query.ts
@@ -0,0 +1,406 @@
+import { type Result, type RichEvent, commands } from "@/commands.gen";
+import type { LumeColumn, Metadata, NostrEvent, Relay } from "@/types";
+import { resolveResource } from "@tauri-apps/api/path";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { open } from "@tauri-apps/plugin-dialog";
+import { readFile, readTextFile } from "@tauri-apps/plugin-fs";
+import { relaunch } from "@tauri-apps/plugin-process";
+import { nip19 } from "nostr-tools";
+import { LumeEvent } from "./event";
+
+function toLumeEvents(richEvents: RichEvent[]) {
+	const events = richEvents.map((item) => {
+		const nostrEvent: NostrEvent = JSON.parse(item.raw);
+
+		if (item.parsed) {
+			nostrEvent.meta = item.parsed;
+		} else {
+			nostrEvent.meta = null;
+		}
+
+		const lumeEvent = new LumeEvent(nostrEvent);
+
+		return lumeEvent;
+	});
+
+	return events;
+}
+
+export const NostrQuery = {
+	upload: async (filePath?: string) => {
+		const allowExts = [
+			"png",
+			"jpeg",
+			"jpg",
+			"gif",
+			"mp4",
+			"mp3",
+			"webm",
+			"mkv",
+			"avi",
+			"mov",
+		];
+
+		const selected =
+			filePath ||
+			(
+				await open({
+					multiple: false,
+					filters: [
+						{
+							name: "Media",
+							extensions: allowExts,
+						},
+					],
+				})
+			).path;
+
+		// User cancelled action
+		if (!selected) return null;
+
+		try {
+			const file = await readFile(selected);
+			const blob = new Blob([file]);
+
+			const data = new FormData();
+			data.append("fileToUpload", blob);
+			data.append("submit", "Upload Image");
+
+			const res = await fetch("https://nostr.build/api/v2/upload/files", {
+				method: "POST",
+				body: data,
+			});
+
+			if (!res.ok) return null;
+
+			const json = await res.json();
+			const content = json.data[0];
+
+			return content.url as string;
+		} catch (e) {
+			throw new Error(String(e));
+		}
+	},
+	getNotifications: async () => {
+		const query = await commands.getNotifications();
+
+		if (query.status === "ok") {
+			const data = query.data.map((item) => JSON.parse(item) as NostrEvent);
+			const events = data.map((ev) => new LumeEvent(ev));
+
+			return events;
+		} else {
+			console.error(query.error);
+			return [];
+		}
+	},
+	getProfile: async (pubkey: string) => {
+		const normalize = pubkey.replace("nostr:", "").replace(/[^\w\s]/gi, "");
+		const query = await commands.getProfile(normalize);
+
+		if (query.status === "ok") {
+			const profile: Metadata = JSON.parse(query.data);
+			return profile;
+		} else {
+			return null;
+		}
+	},
+	getEvent: async (id: string, hint?: string) => {
+		// Validate ID
+		const normalizeId: string = id
+			.replace("nostr:", "")
+			.replace(/[^\w\s]/gi, "");
+
+		// Define query
+		let query: Result<RichEvent, string>;
+		let relayHint: string = hint;
+
+		if (normalizeId.startsWith("nevent1")) {
+			const decoded = nip19.decode(normalizeId);
+			if (decoded.type === "nevent") relayHint = decoded.data.relays[0];
+		}
+
+		// Build query
+		if (relayHint) {
+			try {
+				const url = new URL(relayHint);
+				query = await commands.getEventFrom(normalizeId, url.toString());
+			} catch {
+				query = await commands.getEvent(normalizeId);
+			}
+		} else {
+			query = await commands.getEvent(normalizeId);
+		}
+
+		if (query.status === "ok") {
+			const data = query.data;
+			const raw = JSON.parse(data.raw) as NostrEvent;
+
+			if (data?.parsed) {
+				raw.meta = data.parsed;
+			}
+
+			const event = new LumeEvent(raw);
+
+			return event;
+		} else {
+			console.log("[getEvent]: ", query.error);
+			return null;
+		}
+	},
+	getRepostEvent: async (event: LumeEvent) => {
+		try {
+			const embed: NostrEvent = JSON.parse(event.content);
+			const query = await commands.getEventMeta(embed.content);
+
+			if (query.status === "ok") {
+				embed.meta = query.data;
+				const lumeEvent = new LumeEvent(embed);
+				return lumeEvent;
+			}
+		} catch {
+			const query = await commands.getEvent(event.repostId);
+
+			if (query.status === "ok") {
+				const data = query.data;
+				const raw = JSON.parse(data.raw) as NostrEvent;
+
+				if (data?.parsed) {
+					raw.meta = data.parsed;
+				}
+
+				const event = new LumeEvent(raw);
+
+				return event;
+			} else {
+				console.log("[getRepostEvent]: ", query.error);
+				return null;
+			}
+		}
+	},
+	getUserEvents: async (pubkey: string, asOf?: number) => {
+		const until: string = asOf && asOf > 0 ? asOf.toString() : undefined;
+		const query = await commands.getEventsBy(pubkey, until);
+
+		if (query.status === "ok") {
+			const data = toLumeEvents(query.data);
+			return data;
+		} else {
+			return [];
+		}
+	},
+	getLocalEvents: async (asOf?: number) => {
+		const until: string = asOf && asOf > 0 ? asOf.toString() : undefined;
+		const query = await commands.getLocalEvents(until);
+
+		if (query.status === "ok") {
+			const data = toLumeEvents(query.data);
+			return data;
+		} else {
+			return [];
+		}
+	},
+	listenLocalEvent: async () => {
+		const label = getCurrentWindow().label;
+		const query = await commands.listenLocalEvent(label);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	getGroupEvents: async (pubkeys: string[], asOf?: number) => {
+		const until: string = asOf && asOf > 0 ? asOf.toString() : undefined;
+		const query = await commands.getGroupEvents(pubkeys, until);
+
+		if (query.status === "ok") {
+			const data = toLumeEvents(query.data);
+			return data;
+		} else {
+			return [];
+		}
+	},
+	getGlobalEvents: async (asOf?: number) => {
+		const until: string = asOf && asOf > 0 ? asOf.toString() : undefined;
+		const query = await commands.getGlobalEvents(until);
+
+		if (query.status === "ok") {
+			const data = toLumeEvents(query.data);
+			return data;
+		} else {
+			return [];
+		}
+	},
+	getHashtagEvents: async (hashtags: string[], asOf?: number) => {
+		const until: string = asOf && asOf > 0 ? asOf.toString() : undefined;
+		const nostrTags = hashtags.map((tag) => tag.replace("#", ""));
+		const query = await commands.getHashtagEvents(nostrTags, until);
+
+		if (query.status === "ok") {
+			const data = toLumeEvents(query.data);
+			return data;
+		} else {
+			return [];
+		}
+	},
+	verifyNip05: async (pubkey: string, nip05?: string) => {
+		const query = await commands.verifyNip05(pubkey, nip05);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			return false;
+		}
+	},
+	getNstore: async (key: string) => {
+		const query = await commands.getNstore(key);
+
+		if (query.status === "ok") {
+			const data = query.data ? JSON.parse(query.data) : null;
+			return data;
+		} else {
+			return null;
+		}
+	},
+	setNstore: async (key: string, value: string) => {
+		const query = await commands.setNstore(key, value);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	getUserSettings: async () => {
+		const query = await commands.getSettings();
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			return query.error;
+		}
+	},
+	setUserSettings: async (newSettings: string) => {
+		const query = await commands.setNewSettings(newSettings);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			return query.error;
+		}
+	},
+	getColumns: async () => {
+		const key = "lume:columns";
+		const systemPath = "resources/system_columns.json";
+		const resourcePath = await resolveResource(systemPath);
+		const resourceFile = await readTextFile(resourcePath);
+		const systemColumns: LumeColumn[] = JSON.parse(resourceFile);
+		const query = await commands.getNstore(key);
+
+		try {
+			if (query.status === "ok") {
+				const columns: LumeColumn[] = JSON.parse(query.data);
+
+				if (!columns?.length) {
+					return systemColumns;
+				}
+
+				// Filter "open" column
+				// Reason: deprecated
+				return columns.filter((col) => col.label !== "open");
+			} else {
+				return systemColumns;
+			}
+		} catch {
+			return systemColumns;
+		}
+	},
+	setColumns: async (columns: LumeColumn[]) => {
+		const key = "lume:columns";
+		const content = JSON.stringify(columns);
+		const query = await commands.setNstore(key, content);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	getRelays: async () => {
+		const query = await commands.getRelays();
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	connectRelay: async (url: string) => {
+		const relayUrl = new URL(url);
+
+		if (relayUrl.protocol === "wss:" || relayUrl.protocol === "ws:") {
+			const query = await commands.connectRelay(relayUrl.toString());
+
+			if (query.status === "ok") {
+				return query.data;
+			} else {
+				throw new Error(query.error);
+			}
+		}
+	},
+	removeRelay: async (url: string) => {
+		const relayUrl = new URL(url);
+
+		if (relayUrl.protocol === "wss:" || relayUrl.protocol === "ws:") {
+			const query = await commands.removeRelay(relayUrl.toString());
+
+			if (query.status === "ok") {
+				return query.data;
+			} else {
+				throw new Error(query.error);
+			}
+		}
+	},
+	getBootstrapRelays: async () => {
+		const query = await commands.getBootstrapRelays();
+
+		if (query.status === "ok") {
+			const relays: Relay[] = [];
+
+			for (const item of query.data) {
+				const line = item.split(",");
+				const url = line[0];
+				const purpose = line[1] ?? "";
+
+				relays.push({ url, purpose });
+			}
+
+			return relays;
+		} else {
+			return [];
+		}
+	},
+	saveBootstrapRelays: async (relays: Relay[]) => {
+		const text = relays
+			.map((relay) => Object.values(relay).join(","))
+			.join("\n");
+		const query = await commands.saveBootstrapRelays(text);
+
+		if (query.status === "ok") {
+			return await relaunch();
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	unlisten: async (id?: string) => {
+		const label = id ? id : getCurrentWindow().label;
+		const query = await commands.unlisten(label);
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+};
--- a/src/system/window.ts
+++ b/src/system/window.ts
@@ -0,0 +1,151 @@
+import { commands } from "@/commands.gen";
+import type { NostrEvent } from "@/types";
+import type { LumeEvent } from "./event";
+
+export const LumeWindow = {
+	openMainWindow: async () => {
+		const query = await commands.openMainWindow();
+		return query;
+	},
+	openEvent: async (event: NostrEvent | LumeEvent) => {
+		const eTags = event.tags.filter((tag) => tag[0] === "e" || tag[0] === "q");
+		const root: string =
+			eTags.find((el) => el[3] === "root")?.[1] ?? eTags[0]?.[1];
+		const reply: string =
+			eTags.find((el) => el[3] === "reply")?.[1] ?? eTags[1]?.[1];
+
+		const url = `/events/${root ?? reply ?? event.id}`;
+		const label = `event-${root ?? reply ?? event.id}`;
+
+		const query = await commands.openWindow({
+			label,
+			url,
+			title: "Thread",
+			width: 500,
+			height: 800,
+			maximizable: true,
+			minimizable: true,
+			hidden_title: false,
+		});
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	openProfile: async (pubkey: string) => {
+		const label = `user-${pubkey}`;
+		const query = await commands.openWindow({
+			label,
+			url: `/users/${pubkey}`,
+			title: "Profile",
+			width: 500,
+			height: 800,
+			maximizable: true,
+			minimizable: true,
+			hidden_title: true,
+		});
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	openEditor: async (reply_to?: string, quote?: string) => {
+		let url: string;
+
+		if (reply_to) {
+			url = `/editor?reply_to=${reply_to}`;
+		}
+
+		if (quote?.length) {
+			url = `/editor?quote=${quote}`;
+		}
+
+		if (!reply_to?.length && !quote?.length) {
+			url = "/editor";
+		}
+
+		const label = `editor-${reply_to ? reply_to : 0}`;
+		const query = await commands.openWindow({
+			label,
+			url,
+			title: "Editor",
+			width: 560,
+			height: 340,
+			maximizable: false,
+			minimizable: false,
+			hidden_title: true,
+		});
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	openZap: async (id: string) => {
+		const wallet = await commands.loadWallet();
+
+		if (wallet.status === "ok") {
+			await commands.openWindow({
+				label: `zap-${id}`,
+				url: `/zap/${id}`,
+				title: "Zap",
+				width: 360,
+				height: 460,
+				maximizable: false,
+				minimizable: false,
+				hidden_title: true,
+			});
+		} else {
+			await LumeWindow.openSettings("bitcoin-connect");
+		}
+	},
+	openSettings: async (path?: string) => {
+		const label = "settings";
+		const query = await commands.openWindow({
+			label,
+			url: path ? `/settings/${path}` : "/settings/general",
+			title: "Settings",
+			width: 800,
+			height: 500,
+			maximizable: false,
+			minimizable: false,
+			hidden_title: true,
+		});
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+	openSearch: async (searchType: "notes" | "users", searchQuery: string) => {
+		const url = `/search/${searchType}?query=${searchQuery}`;
+		const label = `search-${searchQuery
+			.toLowerCase()
+			.replace(/[^\w ]+/g, "")
+			.replace(/ +/g, "_")
+			.replace(/_+/g, "_")}`;
+
+		const query = await commands.openWindow({
+			label,
+			url,
+			title: "Search",
+			width: 400,
+			height: 600,
+			maximizable: false,
+			minimizable: false,
+			hidden_title: true,
+		});
+
+		if (query.status === "ok") {
+			return query.data;
+		} else {
+			throw new Error(query.error);
+		}
+	},
+};