feat: export and import of dashboards, also from browser bookmarks

Settings downloads all dashboards with their cards and links as one JSON
file and loads such a file again. The bookmarks file of a browser becomes
a dashboard with a card per folder. An import only adds.
This commit is contained in:
Niklas Haiden
2026-11-21 19:21:37 +01:00
parent b6e5d81dc0
commit af73a386ed
5 changed files with 427 additions and 0 deletions
+6
View File
@@ -83,6 +83,12 @@ Build it yourself: `docker build -t dahoam .`
upload (JPEG, PNG, WebP, AVIF, up to 10 MB). A slider sets how much it is darkened. upload (JPEG, PNG, WebP, AVIF, up to 10 MB). A slider sets how much it is darkened.
Each dashboard has its own: the pencil opens the one of the dashboard you are on, and Each dashboard has its own: the pencil opens the one of the dashboard you are on, and
Settings → Wallpaper has a switch for the others. Settings → Wallpaper has a switch for the others.
- **Export and import**: Settings → Export and import downloads all dashboards with their
cards and links as one JSON file, and loads such a file again. It also takes the bookmarks
file that a browser exports (HTML) and makes a dashboard "Bookmarks" of it, with a card per
folder. An import adds dashboards and replaces nothing. Uploaded wallpapers and icons are
not part of an export.
- **Password**: Settings → Account changes it. That signs you out on your other devices.
- **Clock**: Settings has five fonts and three styles. Glass shows the wallpaper blurred - **Clock**: Settings has five fonts and three styles. Glass shows the wallpaper blurred
through the digits, Tinted takes its color from the wallpaper. through the digits, Tinted takes its color from the wallpaper.
+89
View File
@@ -17,6 +17,8 @@ import { libraryNames } from "@/lib/icon-library"
import { lightVariant } from "@/lib/icons" import { lightVariant } from "@/lib/icons"
import { ENGINES, parseSuggestions } from "@/lib/search" import { ENGINES, parseSuggestions } from "@/lib/search"
import { isReachable, statusChecks } from "@/lib/status" import { isReachable, statusChecks } from "@/lib/status"
import { backupSchema, portable } from "@/lib/transfer"
import type { Backup } from "@/lib/transfer"
const httpUrl = z.url({ protocol: /^https?$/ }).max(2000) const httpUrl = z.url({ protocol: /^https?$/ }).max(2000)
@@ -361,6 +363,93 @@ export const saveWallpaper = createServerFn({ method: "POST" })
await db.delete(wallpaper).where(eq(wallpaper.dashboardId, dashboardId)) await db.delete(wallpaper).where(eq(wallpaper.dashboardId, dashboardId))
}) })
/** Every dashboard of the user with its cards and links, see backupSchema. */
export const exportData = createServerFn({ method: "GET" }).handler(
async (): Promise<Backup> => {
const user = await requireUser()
const [dashboards, cards, links] = await Promise.all([
db
.select()
.from(dashboard)
.where(eq(dashboard.userId, user.id))
.orderBy(asc(dashboard.createdAt)),
db
.select()
.from(card)
.where(eq(card.userId, user.id))
.orderBy(asc(card.position), asc(card.createdAt)),
db
.select()
.from(link)
.where(eq(link.userId, user.id))
.orderBy(asc(link.position), asc(link.createdAt)),
])
return {
dashboards: dashboards.map((d) => ({
name: d.name,
wallpaperUrl: portable(d.wallpaperUrl),
wallpaperDim: d.wallpaperDim,
cards: cards
.filter((c) => c.dashboardId === d.id)
.map((c) => ({
name: c.name,
links: links
.filter((l) => l.cardId === c.id)
.map((l) => ({
name: l.name,
url: l.url,
icon: portable(l.icon),
})),
})),
})),
}
}
)
/** Adds the dashboards of an export or of a bookmarks file. Nothing is replaced. */
export const importData = createServerFn({ method: "POST" })
.validator(backupSchema)
.handler(async ({ data }) => {
const user = await requireUser()
const userId = user.id
const added = { dashboards: data.dashboards.length, cards: 0, links: 0 }
// all of the file or nothing of it
await db.transaction(async (tx) => {
for (const d of data.dashboards) {
const [{ id: dashboardId }] = await tx
.insert(dashboard)
.values({
userId,
name: d.name,
wallpaperUrl: d.wallpaperUrl,
wallpaperDim: d.wallpaperDim,
})
.returning({ id: dashboard.id })
for (const [position, c] of d.cards.entries()) {
const [{ id: cardId }] = await tx
.insert(card)
.values({ userId, dashboardId, position, name: c.name })
.returning({ id: card.id })
added.cards++
added.links += c.links.length
if (c.links.length)
await tx.insert(link).values(
c.links.map((l, at) => ({
userId,
cardId,
position: at,
name: l.name,
url: l.url,
// an upload of another account would not load here
icon: portable(l.icon),
}))
)
}
}
})
return added
})
export const suggest = createServerFn({ method: "GET" }) export const suggest = createServerFn({ method: "GET" })
.validator(z.object({ q: z.string().max(200), searxng: z.boolean() })) .validator(z.object({ q: z.string().max(200), searxng: z.boolean() }))
.handler(async ({ data }) => { .handler(async ({ data }) => {
+99
View File
@@ -0,0 +1,99 @@
import assert from "node:assert/strict"
import { test } from "node:test"
import { backupSchema, parseBookmarks, portable } from "./transfer.ts"
// what Firefox and Chrome write, shortened
const BOOKMARKS = `<!DOCTYPE NETSCAPE-Bookmark-file-1>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
<TITLE>Bookmarks</TITLE>
<H1>Bookmarks</H1>
<DL><p>
<DT><A HREF="https://example.com/top" ADD_DATE="1">Top level</A>
<DT><H3 ADD_DATE="1" PERSONAL_TOOLBAR_FOLDER="true">Bookmarks bar</H3>
<DL><p>
<DT><A HREF="https://git.example.com/?a=1&amp;b=2" ICON="data:image/png;base64,AAAA">Git &amp; &quot;CI&quot; &#252;</A>
<DT><H3>Media</H3>
<DL><p>
<DT><A HREF="http://plex.lan:32400/web">Plex</A>
<DT><A HREF="javascript:alert(1)">A bookmarklet</A>
<DT><A HREF="https://nameless.example.com/x"></A>
</DL><p>
<DT><A HREF="place:sort=8">Most visited</A>
</DL><p>
<DT><H3>Empty folder</H3>
<DL><p>
</DL><p>
</DL><p>`
test("parseBookmarks: a card per folder that has bookmarks", () => {
const found = parseBookmarks(BOOKMARKS)
assert.ok(found)
assert.equal(found.skipped, 2) // the bookmarklet and place:
assert.deepEqual(found.backup, {
dashboards: [
{
name: "Bookmarks",
cards: [
{
name: "Bookmarks",
links: [{ name: "Top level", url: "https://example.com/top" }],
},
{
name: "Bookmarks bar",
links: [
{ name: 'Git & "CI" ü', url: "https://git.example.com/?a=1&b=2" },
],
},
{
name: "Media",
links: [
{ name: "Plex", url: "http://plex.lan:32400/web" },
{
name: "nameless.example.com",
url: "https://nameless.example.com/x",
},
],
},
],
},
],
})
// what it makes is what an import takes
assert.ok(backupSchema.safeParse(found.backup).success)
})
test("parseBookmarks: limits, long names, files without bookmarks", () => {
assert.equal(parseBookmarks("<html><body>Hello</body></html>"), null)
assert.equal(parseBookmarks('{"dashboards": []}'), null)
const many = Array.from(
{ length: 502 },
(_, i) => `<DT><A HREF="https://example.com/${i}">${"n".repeat(70)}</A>`
).join("")
const found = parseBookmarks(`<DL>${many}</DL>`)
assert.ok(found)
assert.equal(found.backup.dashboards[0].cards[0].links.length, 500)
assert.equal(found.backup.dashboards[0].cards[0].links[0].name.length, 60)
assert.equal(found.skipped, 2)
assert.ok(backupSchema.safeParse(found.backup).success)
})
test("backupSchema refuses what is not a web address", () => {
const withUrl = (url: string) => ({
dashboards: [
{ name: "D", cards: [{ name: "C", links: [{ name: "L", url }] }] },
],
})
assert.ok(backupSchema.safeParse(withUrl("https://example.com")).success)
assert.ok(!backupSchema.safeParse(withUrl("javascript:alert(1)")).success)
assert.ok(!backupSchema.safeParse({ dashboards: [] }).success)
})
test("portable: uploads stay with their account", () => {
assert.equal(portable("/api/icon?id=1"), null)
assert.equal(portable("plex"), "plex")
assert.equal(
portable("https://example.com/a.png"),
"https://example.com/a.png"
)
assert.equal(portable(null), null)
})
+116
View File
@@ -0,0 +1,116 @@
// Export and import: the shape of the file, and how a browser's bookmarks become one.
import { z } from "zod"
const httpUrl = z.url({ protocol: /^https?$/ }).max(2000)
const MAX_CARDS = 100
const MAX_LINKS = 500 // per card
/**
* What an export holds and an import takes: dashboards with their cards and links.
* Uploaded wallpapers and icons are not in it, they belong to one account.
*/
export const backupSchema = z.object({
dashboards: z
.array(
z.object({
name: z.string().trim().min(1).max(40),
// an image on the web; null or missing: the default photo
wallpaperUrl: httpUrl.nullish(),
wallpaperDim: z.int().min(0).max(100).optional(),
cards: z
.array(
z.object({
name: z.string().trim().min(1).max(40),
links: z
.array(
z.object({
name: z.string().trim().min(1).max(60),
url: httpUrl,
// an image on the web or a name in the icon library
icon: z.string().trim().max(2000).nullish(),
})
)
.max(MAX_LINKS),
})
)
.max(MAX_CARDS),
})
)
.min(1)
.max(20),
})
export type Backup = z.infer<typeof backupSchema>
/** An upload ("/api/icon?id=…") only works for the account that made it. */
export const portable = (address?: string | null) =>
!address || address.startsWith("/") ? null : address
const ENTITIES: Record<string, string> = {
amp: "&",
lt: "<",
gt: ">",
quot: '"',
apos: "'",
}
const text = (html: string) =>
html
.replace(/<[^>]*>/g, "")
.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (entity, code: string) => {
if (code[0] !== "#") return ENTITIES[code.toLowerCase()] ?? entity
const point =
code[1].toLowerCase() === "x"
? parseInt(code.slice(2), 16)
: parseInt(code.slice(1), 10)
return point <= 0x10ffff ? String.fromCodePoint(point) : entity
})
.trim()
/**
* The bookmarks file that every browser exports (HTML) as one dashboard: a card per
* folder that has bookmarks, named like the folder. `skipped` counts what was left out:
* addresses that are not http(s), and what is over the limits of an import.
* Null when the file has no bookmark in it.
*/
export function parseBookmarks(html: string) {
const cards = new Map<string, Backup["dashboards"][0]["cards"][0]>()
const folders: string[] = [] // the path to where we are
let heading: string | null = null // a folder name that waits for its <DL>
let skipped = 0
const tags =
/<DL\b|<\/DL>|<H3\b[^>]*>([\s\S]*?)<\/H3>|<A\b([^>]*)>([\s\S]*?)<\/A>/gi
for (const [tag, folder, attributes, title] of html.matchAll(tags)) {
if (/^<DL/i.test(tag)) {
folders.push(heading ?? "")
heading = null
} else if (/^<\/DL/i.test(tag)) folders.pop()
else if (/^<H3/i.test(tag)) heading = text(folder)
else {
const href = /\bHREF\s*=\s*"([^"]*)"/i.exec(attributes)
const url = httpUrl.safeParse(text(href?.[1] ?? ""))
// two folders with the same name stay two cards
const path = folders.join("\n")
const card = cards.get(path) ?? {
name: (folders.filter(Boolean).at(-1) ?? "Bookmarks").slice(0, 40),
links: [],
}
if (
!url.success ||
card.links.length >= MAX_LINKS ||
(!cards.has(path) && cards.size >= MAX_CARDS)
) {
skipped++
continue
}
cards.set(path, card)
card.links.push({
name: (text(title) || new URL(url.data).hostname).slice(0, 60),
url: url.data,
})
}
}
if (!cards.size) return null
const backup: Backup = {
dashboards: [{ name: "Bookmarks", cards: [...cards.values()] }],
}
return { backup, skipped }
}
+117
View File
@@ -8,10 +8,12 @@ import {
useRouter, useRouter,
} from "@tanstack/react-router" } from "@tanstack/react-router"
import { import {
ArrowDownUp,
ArrowLeft, ArrowLeft,
Check, Check,
CircleUser, CircleUser,
Clock, Clock,
Download,
Image, Image,
LayoutDashboard, LayoutDashboard,
LogOut, LogOut,
@@ -33,13 +35,17 @@ import {
import type { ClockFont, ClockStyle } from "@/lib/clock" import type { ClockFont, ClockStyle } from "@/lib/clock"
import { import {
deleteDashboard, deleteDashboard,
exportData,
getDashboard, getDashboard,
importData,
saveDashboard, saveDashboard,
saveSettings, saveSettings,
saveWallpaper, saveWallpaper,
} from "@/lib/dashboard.functions" } from "@/lib/dashboard.functions"
import { ENGINES, ENGINE_NAMES } from "@/lib/search" import { ENGINES, ENGINE_NAMES } from "@/lib/search"
import type { Engine } from "@/lib/search" import type { Engine } from "@/lib/search"
import { parseBookmarks } from "@/lib/transfer"
import type { Backup } from "@/lib/transfer"
import { Button } from "@/vendor/collabry/components/Button/Button" import { Button } from "@/vendor/collabry/components/Button/Button"
import { import {
Field, Field,
@@ -95,6 +101,7 @@ const SECTIONS = [
{ id: "clock", label: "Clock", icon: Clock }, { id: "clock", label: "Clock", icon: Clock },
{ id: "search", label: "Search", icon: Search }, { id: "search", label: "Search", icon: Search },
{ id: "wallpaper", label: "Wallpaper", icon: Image }, { id: "wallpaper", label: "Wallpaper", icon: Image },
{ id: "transfer", label: "Export and import", icon: ArrowDownUp },
{ id: "account", label: "Account", icon: CircleUser }, { id: "account", label: "Account", icon: CircleUser },
] ]
@@ -130,6 +137,9 @@ function Settings() {
const router = useRouter() const router = useRouter()
const hash = useLocation({ select: (l) => l.hash }) || SECTIONS[0].id const hash = useLocation({ select: (l) => l.hash }) || SECTIONS[0].id
const file = useRef<HTMLInputElement>(null) const file = useRef<HTMLInputElement>(null)
const importFile = useRef<HTMLInputElement>(null)
// what the last import added
const [imported, setImported] = useState("")
const [status, setStatus] = useState<"idle" | "saving" | "saved">("idle") const [status, setStatus] = useState<"idle" | "saving" | "saved">("idle")
const [error, setError] = useState("") const [error, setError] = useState("")
// follows the slider at once, the save comes a moment later // follows the slider at once, the save comes a moment later
@@ -174,6 +184,47 @@ function Settings() {
const uploaded = !!data.wallpaperUrl?.startsWith("/") const uploaded = !!data.wallpaperUrl?.startsWith("/")
const download = async () => {
const backup = await exportData()
const url = URL.createObjectURL(
new Blob([JSON.stringify(backup, null, 2)], { type: "application/json" })
)
const a = document.createElement("a")
a.href = url
a.download = `dahoam-${new Date().toISOString().slice(0, 10)}.json`
a.click()
URL.revokeObjectURL(url)
}
// an export of this app (JSON) or the bookmarks file of a browser (HTML)
const importFrom = (chosen: File) =>
run(async () => {
setImported("")
if (chosen.size > 5 * 1024 * 1024) return "The file is larger than 5 MB."
const content = await chosen.text()
let backup: unknown
let skipped = 0
try {
backup = JSON.parse(content)
} catch {
const bookmarks = parseBookmarks(content)
if (!bookmarks) return "This file has no dashboards or bookmarks in it."
;({ backup, skipped } = bookmarks)
}
// whether it really is one, the server checks
const added = await importData({ data: backup as Backup }).catch(
() => null
)
if (!added) return "This file is not an export of Dahoam."
const count = (n: number, thing: string) =>
`${n} ${thing}${n === 1 ? "" : "s"}`
setImported(
`Added ${count(added.dashboards, "dashboard")} with ${count(added.cards, "card")} and ${count(added.links, "link")}.` +
(skipped
? ` ${count(skipped, "bookmark")} left out: not a web address, or more than a card holds.`
: "")
)
})
return ( return (
// A page of its own: solid Collabry surfaces, no wallpaper behind it // A page of its own: solid Collabry surfaces, no wallpaper behind it
<div className="min-h-svh bg-app"> <div className="min-h-svh bg-app">
@@ -616,6 +667,72 @@ function Settings() {
</SettingsRow> </SettingsRow>
</SettingsSection> </SettingsSection>
<SettingsSection id="transfer" className={section}>
<SettingsSectionHeader>
<SettingsSectionTitle>Export and import</SettingsSectionTitle>
<SettingsSectionDescription>
Keep a copy of your dashboards, move them to another
account, or start from the bookmarks of your browser.
</SettingsSectionDescription>
</SettingsSectionHeader>
<SettingsRow>
<SettingsRowText>
<div className="leading-tight font-bold">Export</div>
<SettingsRowDescription>
One file with all dashboards, their cards and links.
Images that you uploaded are not in it.
</SettingsRowDescription>
</SettingsRowText>
<SettingsRowControl>
<Button
onClick={() =>
download().catch(() => setError("Could not export."))
}
>
<Download size={15} /> Export
</Button>
</SettingsRowControl>
</SettingsRow>
<SettingsRow>
<SettingsRowText>
<div className="leading-tight font-bold">Import</div>
<SettingsRowDescription>
An export of Dahoam, or the bookmarks file that your
browser exports (HTML): a dashboard "Bookmarks" with a
card per folder. An import adds dashboards, it replaces
nothing.
</SettingsRowDescription>
{imported && (
<SettingsRowDescription
role="status"
className="text-success-fg"
>
{imported}
</SettingsRowDescription>
)}
</SettingsRowText>
<SettingsRowControl>
<input
ref={importFile}
type="file"
accept=".json,.html,.htm,application/json,text/html"
className="hidden"
onChange={(e) => {
const chosen = e.target.files?.[0]
if (chosen) void importFrom(chosen)
e.target.value = ""
}}
/>
<Button
disabled={status === "saving"}
onClick={() => importFile.current?.click()}
>
<Upload size={15} /> Choose a file
</Button>
</SettingsRowControl>
</SettingsRow>
</SettingsSection>
<SettingsSection id="account" className={section}> <SettingsSection id="account" className={section}>
<SettingsSectionHeader> <SettingsSectionHeader>
<SettingsSectionTitle>Account</SettingsSectionTitle> <SettingsSectionTitle>Account</SettingsSectionTitle>