diff --git a/src/client/tab-persist.ts b/src/client/tab-persist.ts new file mode 100644 index 0000000..dce1fed --- /dev/null +++ b/src/client/tab-persist.ts @@ -0,0 +1,105 @@ +/** + * Client side of the session-tab persistence, talking to + * `GET|PUT /workspace-groups/tabs` on the host. + * + * Why not browser storage: **the origin includes the PORT**, and every `dsh web` + * / `dsh test` / desktop launch picks a different one. `localStorage` and + * `sessionStorage` are both scoped to the origin, so they start empty on the + * next launch — a tab list kept there survives a reload only when the port + * happens to match. The host's JSON sidecar has no such problem, which is why + * the strip is stored there and read back verbatim. + * + * There is deliberately no per-browser-session marker. A marker has to live in + * browser storage, which the port invalidates, so every restart looked like a + * fresh session and silently discarded the user's tabs — the exact failure this + * module exists to prevent. + * + * Every call is best-effort: a failed read means "no tabs" and a failed write is + * swallowed, because the strip is a convenience and must never break the app. + */ + +/** Host route holding the strip. */ +export const TABS_ROUTE = '/workspace-groups/tabs' + +/** One tab as it crosses the wire. */ +export interface WireTab { + readonly sessionId: string + readonly order: number + /** Pinned tabs are restored at the front of the strip. */ + readonly pinned?: boolean + /** A label the user typed for the tab itself (absent = follow the session). */ + readonly title?: string +} + +/** + * Read one tab row off the wire, dropping the row when it is unusable. + * @param entry - one element of the stored `tabs` array. + * @returns the tab, or null for a malformed row. + */ +function parseWireTab(entry: unknown): WireTab | null { + if (typeof entry !== 'object' || entry === null) return null + const row = entry as Record + if (typeof row.sessionId !== 'string' || row.sessionId === '') return null + if (typeof row.order !== 'number' || !Number.isFinite(row.order)) return null + const pinned = row.pinned === true + const title = typeof row.title === 'string' && row.title.trim() !== '' ? row.title.trim() : undefined + return { + sessionId: row.sessionId, + order: row.order, + ...(pinned ? { pinned: true } : {}), + ...(title !== undefined ? { title } : {}), + } +} + +/** + * Fetch the stored strip. + * @param fetchImpl - fetch implementation (injectable for tests). + * @returns the tabs, oldest first; empty on any failure. + */ +export async function loadTabs(fetchImpl: typeof fetch = fetch): Promise { + try { + const response = await fetchImpl(TABS_ROUTE, { + method: 'GET', + // Per-session state; a cached response would restore stale tabs. + cache: 'no-store', + }) + if (!response.ok) return [] + const body: unknown = await response.json() + if (typeof body !== 'object' || body === null) return [] + const list = (body as { tabs?: unknown }).tabs + if (!Array.isArray(list)) return [] + const tabs: WireTab[] = [] + for (const entry of list) { + const tab = parseWireTab(entry) + if (tab !== null) tabs.push(tab) + } + return tabs + } catch { + return [] + } +} + +/** + * Store the strip. Failures are swallowed. + * @param state - the client's current strip and its arrival counter. + * @param fetchImpl - fetch implementation (injectable for tests). + */ +export async function saveTabs( + state: { order: number; tabs: readonly WireTab[] }, + fetchImpl: typeof fetch = fetch, +): Promise { + try { + await fetchImpl(TABS_ROUTE, { + method: 'PUT', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ order: state.order, tabs: state.tabs }), + cache: 'no-store', + // Survive a navigation that happens while the request is in flight; the + // write is idempotent so a re-send is harmless. + keepalive: true, + }) + } catch { + // Offline or the host is restarting: the next change writes the full state + // again, so nothing is lost beyond this tick. + } +}