Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

fix(desktop): preserve login across upgrades

tianma-ifb04f15f7fd13
diff --git a/apps/desktop/src/main/index.mjs b/apps/desktop/src/main/index.mjs
index 951f27ab..c834106a 100644
--- a/apps/desktop/src/main/index.mjs
+++ b/apps/desktop/src/main/index.mjs
@@ -1,4 +1,4 @@
-import { app, BrowserWindow, Menu, Tray, nativeImage, ipcMain, session, net, protocol, shell, dialog } from "electron";
+import { app, BrowserWindow, Menu, Tray, nativeImage, ipcMain, session, net, protocol, shell, dialog, safeStorage } from "electron";
import { existsSync } from "node:fs";
import { appendFile, mkdir, readdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
import { basename, join } from "node:path";
@@ -57,9 +57,11 @@ let sidecarRestartInFlight = false;
const hasSingleInstanceLock = app.requestSingleInstanceLock();
const windowStatePath = () => join(app.getPath("userData"), "window-state.json");
const instanceUrlPath = () => join(app.getPath("userData"), "instance-url");
+const sessionTokenPath = () => join(app.getPath("userData"), "session-token");
const crashMarkerPath = () => join(app.getPath("userData"), "last-session-active");
const installationMarkerPath = () => join(app.getPath("userData"), "installation-confirmed");
const logPath = () => join(app.getPath("userData"), "logs", "desktop.log");
+let desktopSessionToken = "";
const sidecarDataDirectory = (accountId = null) => {
return accountId
? accountDataDirectory(app.getPath("userData"), configuredApiBaseUrl, accountId)
@@ -192,6 +194,29 @@ const loadConfiguredApiBaseUrl = async () => {
}
};
+const loadDesktopSessionToken = async () => {
+ try {
+ const encrypted = await readFile(sessionTokenPath());
+ desktopSessionToken = safeStorage.decryptString(encrypted);
+ } catch {
+ // Existing installations have no main-process credential until the
+ // renderer migrates the legacy localStorage token after upgrading.
+ desktopSessionToken = "";
+ }
+};
+
+const saveDesktopSessionToken = async (value) => {
+ const normalized = typeof value === "string" ? value.trim() : "";
+ if (normalized.length > 4096) throw new Error("Desktop session token is too long");
+ desktopSessionToken = normalized;
+ const encrypted = safeStorage.encryptString(normalized);
+ const temporaryPath = `${sessionTokenPath()}.tmp`;
+ await writeFile(temporaryPath, encrypted, { mode: 0o600 });
+ await restrictFile(temporaryPath);
+ await rename(temporaryPath, sessionTokenPath());
+ await restrictFile(sessionTokenPath());
+};
+
const pendingDesktopCommands = [];
const sendDesktopCommand = (command) => {
@@ -581,6 +606,7 @@ app.whenReady().then(async () => {
return;
}
await loadConfiguredApiBaseUrl();
+ await loadDesktopSessionToken();
app.setAsDefaultProtocolClient("edgeever");
const previousSessionWasActive = existsSync(crashMarkerPath());
void writeDiagnostic(previousSessionWasActive ? "session.recovered-after-abnormal-exit" : "session.started");
@@ -615,6 +641,15 @@ app.whenReady().then(async () => {
flushPendingMarkdownImport();
});
ipcMain.on("desktop:api-base-url-sync", (event) => { event.returnValue = configuredApiBaseUrl; });
+ ipcMain.on("desktop:session-token-sync", (event) => { event.returnValue = desktopSessionToken; });
+ ipcMain.handle("desktop:set-session-token", async (_event, value) => {
+ await saveDesktopSessionToken(value);
+ return { stored: Boolean(desktopSessionToken) };
+ });
+ ipcMain.handle("desktop:clear-session-token", async () => {
+ await saveDesktopSessionToken("");
+ return { stored: false };
+ });
ipcMain.handle("desktop:set-api-base-url", async (_event, value) => {
const normalized = typeof value === "string" ? value.trim().replace(/\/$/, "") : "";
if (normalized) {
diff --git a/apps/desktop/src/preload/index.cjs b/apps/desktop/src/preload/index.cjs
index 2c2138ea..500017bb 100644
--- a/apps/desktop/src/preload/index.cjs
+++ b/apps/desktop/src/preload/index.cjs
@@ -6,6 +6,9 @@ contextBridge.exposeInMainWorld("edgeeverDesktop", Object.freeze({
setAccountScope: (accountId) => ipcRenderer.invoke("desktop:set-account-scope", accountId),
apiBaseUrl: ipcRenderer.sendSync("desktop:api-base-url-sync"),
setApiBaseUrl: (value) => ipcRenderer.invoke("desktop:set-api-base-url", value),
+ getSessionToken: () => ipcRenderer.sendSync("desktop:session-token-sync"),
+ setSessionToken: (value) => ipcRenderer.invoke("desktop:set-session-token", value),
+ clearSessionToken: () => ipcRenderer.invoke("desktop:clear-session-token"),
updateStatus: () => ipcRenderer.invoke("desktop:update-status"),
downloadUpdate: () => ipcRenderer.invoke("desktop:download-update"),
installUpdate: () => ipcRenderer.invoke("desktop:install-update"),
diff --git a/apps/web/src/app/App.tsx b/apps/web/src/app/App.tsx
index e3ce23ea..0572093e 100644
--- a/apps/web/src/app/App.tsx
+++ b/apps/web/src/app/App.tsx
@@ -68,7 +68,7 @@ const AuthenticatedWorkspace = () => {
queryFn: async () => {
try {
const session = await api.getSession();
- cacheDesktopSession(session);
+ await cacheDesktopSession(session);
return session;
} catch (error) {
const cached = getCachedDesktopSession();
@@ -106,10 +106,11 @@ const AuthenticatedWorkspace = () => {
if (desktopBridge?.isAvailable && payload.instanceUrl !== undefined) {
await saveDesktopApiBaseUrl(payload.instanceUrl);
}
- return api.login({ username: payload.username, password: payload.password });
+ const session = await api.login({ username: payload.username, password: payload.password });
+ await cacheDesktopSession(session);
+ return session;
},
onSuccess: (session) => {
- cacheDesktopSession(session);
queryClient.clear();
queryClient.setQueryData(["auth", "session"], session);
},
diff --git a/apps/web/src/lib/api.test.mjs b/apps/web/src/lib/api.test.mjs
index 0c403a68..3171f92a 100644
--- a/apps/web/src/lib/api.test.mjs
+++ b/apps/web/src/lib/api.test.mjs
@@ -4,6 +4,8 @@ const storage = new Map();
const calls = [];
const events = [];
let completeSave;
+let secureSessionToken = "";
+let failSecureSessionWrite = false;
globalThis.window = {
edgeeverDesktop: {
@@ -21,6 +23,16 @@ globalThis.window = {
calls.push(["bridge:complete", value]);
return value;
},
+ getSessionToken: () => secureSessionToken,
+ setSessionToken: async (value) => {
+ if (failSecureSessionWrite) throw new Error("secure storage unavailable");
+ secureSessionToken = value;
+ return { stored: Boolean(value) };
+ },
+ clearSessionToken: async () => {
+ secureSessionToken = "";
+ return { stored: false };
+ },
},
localStorage: {
getItem: (key) => storage.get(key) ?? null,
@@ -42,6 +54,7 @@ const {
DESKTOP_API_BASE_URL_STORAGE_KEY,
api,
cacheDesktopSession,
+ clearCachedDesktopSession,
getConfiguredDesktopApiBaseUrl,
getCachedDesktopSession,
saveDesktopApiBaseUrl,
@@ -70,7 +83,7 @@ describe("desktop instance setup", () => {
calls.length = 0;
window.edgeeverDesktop.apiBaseUrl = "https://notes.example.com";
storage.set(DESKTOP_API_BASE_URL_STORAGE_KEY, "https://notes.example.com");
- cacheDesktopSession({
+ await cacheDesktopSession({
authRequired: true,
authenticated: true,
demoMode: false,
@@ -94,8 +107,8 @@ describe("desktop instance setup", () => {
window.edgeeverDesktop.apiBaseUrl = "";
});
- test("preserves the desktop token when refreshing the same authenticated session", () => {
- cacheDesktopSession({
+ test("preserves the desktop token when refreshing the same authenticated session", async () => {
+ await cacheDesktopSession({
authRequired: true,
authenticated: true,
demoMode: false,
@@ -103,7 +116,7 @@ describe("desktop instance setup", () => {
user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
});
- cacheDesktopSession({
+ await cacheDesktopSession({
authRequired: true,
authenticated: true,
demoMode: false,
@@ -114,13 +127,12 @@ describe("desktop instance setup", () => {
authRequired: true,
authenticated: true,
demoMode: false,
- sessionToken: "desktop-session-token",
user: { id: "user-1", username: "admin", displayName: "Owner", role: "owner" },
});
});
- test("does not carry a desktop token into a different account session", () => {
- cacheDesktopSession({
+ test("does not carry a desktop token into a different account session", async () => {
+ await cacheDesktopSession({
authRequired: true,
authenticated: true,
demoMode: false,
@@ -128,7 +140,7 @@ describe("desktop instance setup", () => {
user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
});
- cacheDesktopSession({
+ await cacheDesktopSession({
authRequired: true,
authenticated: true,
demoMode: false,
@@ -138,11 +150,114 @@ describe("desktop instance setup", () => {
expect(getCachedDesktopSession()?.sessionToken).toBeUndefined();
});
+ test("migrates a legacy localStorage token into desktop secure storage", async () => {
+ clearCachedDesktopSession();
+ await Promise.resolve();
+ storage.set("edgeever.desktop.session", JSON.stringify({
+ authRequired: true,
+ authenticated: true,
+ demoMode: false,
+ sessionToken: "legacy-session-token",
+ user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
+ }));
+
+ const requests = [];
+ globalThis.fetch = async (_url, init) => {
+ requests.push(new Headers(init?.headers).get("Authorization"));
+ return Response.json({
+ authRequired: true,
+ authenticated: true,
+ demoMode: false,
+ user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
+ });
+ };
+
+ const session = await api.getSession();
+ await cacheDesktopSession(session);
+
+ expect(requests).toEqual(["Bearer legacy-session-token"]);
+ expect(secureSessionToken).toBe("legacy-session-token");
+ expect(getCachedDesktopSession()?.sessionToken).toBeUndefined();
+ });
+
+ test("keeps a localStorage fallback when secure token persistence fails", async () => {
+ failSecureSessionWrite = true;
+ await cacheDesktopSession({
+ authRequired: true,
+ authenticated: true,
+ demoMode: false,
+ sessionToken: "fallback-session-token",
+ user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
+ });
+ failSecureSessionWrite = false;
+
+ expect(getCachedDesktopSession()?.sessionToken).toBe("fallback-session-token");
+ });
+
+ test("keeps secure credentials out of unauthenticated session snapshots", async () => {
+ await cacheDesktopSession({
+ authRequired: true,
+ authenticated: true,
+ demoMode: false,
+ sessionToken: "desktop-session-token",
+ user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
+ });
+ await Promise.resolve();
+
+ await cacheDesktopSession({
+ authRequired: true,
+ authenticated: false,
+ demoMode: false,
+ user: null,
+ });
+
+ expect(secureSessionToken).toBe("desktop-session-token");
+ expect(getCachedDesktopSession()).toEqual({
+ authRequired: true,
+ authenticated: false,
+ demoMode: false,
+ user: null,
+ });
+ });
+
+ test("clears a secure token only after the server rejects that exact credential", async () => {
+ events.length = 0;
+ await cacheDesktopSession({
+ authRequired: true,
+ authenticated: true,
+ demoMode: false,
+ sessionToken: "rejected-session-token",
+ user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
+ });
+ await Promise.resolve();
+
+ globalThis.fetch = async () => Response.json({
+ authRequired: true,
+ authenticated: false,
+ demoMode: false,
+ user: null,
+ });
+
+ await expect(api.getSession()).resolves.toMatchObject({ authenticated: false });
+ await Promise.resolve();
+ expect(secureSessionToken).toBe("");
+ expect(events).toEqual(["edgeever:unauthorized"]);
+
+ globalThis.fetch = async () => Response.json({
+ authRequired: true,
+ authenticated: true,
+ demoMode: false,
+ sessionToken: "replacement-session-token",
+ user: { id: "user-1", username: "admin", displayName: null, role: "owner" },
+ });
+ await cacheDesktopSession(await api.login({ username: "admin", password: "secret" }));
+ });
+
test("uses the desktop session token and stops network retries after a 401", async () => {
calls.length = 0;
events.length = 0;
storage.set(DESKTOP_API_BASE_URL_STORAGE_KEY, "https://notes.example.com");
- cacheDesktopSession({
+ await cacheDesktopSession({
authRequired: true,
authenticated: true,
demoMode: false,
@@ -181,7 +296,7 @@ describe("desktop instance setup", () => {
};
const replacement = await api.login({ username: "admin", password: "secret" });
- cacheDesktopSession(replacement);
+ await cacheDesktopSession(replacement);
await api.syncBootstrap({ limit: 200 });
expect(requests.at(-1)).toEqual({
diff --git a/apps/web/src/lib/api.ts b/apps/web/src/lib/api.ts
index 020dd3c4..419b76e6 100644
--- a/apps/web/src/lib/api.ts
+++ b/apps/web/src/lib/api.ts
@@ -60,6 +60,7 @@ type ListLoginDeviceSessionsResponse = { sessions: LoginDeviceSession[] };
const WEB_DEVICE_ID_STORAGE_KEY = "edgeever.web.device-id";
export const DESKTOP_API_BASE_URL_STORAGE_KEY = "edgeever.desktop.api-base-url";
const DESKTOP_SESSION_STORAGE_KEY = "edgeever.desktop.session";
+let desktopSessionToken: string | null | undefined;
export const getCachedDesktopSession = (): AuthSession | null => {
if (typeof window === "undefined" || !window.edgeeverDesktop?.isAvailable) return null;
@@ -73,20 +74,54 @@ export const getCachedDesktopSession = (): AuthSession | null => {
}
};
-export const cacheDesktopSession = (session: AuthSession) => {
+const getDesktopSessionToken = () => {
+ if (typeof window === "undefined" || !window.edgeeverDesktop?.isAvailable) return undefined;
+ if (desktopSessionToken) return desktopSessionToken;
+
+ const storedToken = window.edgeeverDesktop.getSessionToken().trim();
+ const legacyToken = getCachedDesktopSession()?.sessionToken?.trim() ?? "";
+ // A legacy token remains only when secure persistence has not completed,
+ // so it must win over a possibly stale encrypted file from an earlier login.
+ desktopSessionToken = legacyToken || storedToken || null;
+ return desktopSessionToken ?? undefined;
+};
+
+const setDesktopSessionToken = async (value: string) => {
+ desktopSessionToken = value;
+ try {
+ await window.edgeeverDesktop?.setSessionToken(value);
+ return true;
+ } catch {
+ return false;
+ }
+};
+
+const clearDesktopSessionToken = () => {
+ desktopSessionToken = null;
+ void window.edgeeverDesktop?.clearSessionToken().catch(() => {});
+};
+
+export const cacheDesktopSession = async (session: AuthSession) => {
if (typeof window === "undefined" || !window.edgeeverDesktop?.isAvailable) return;
try {
const cached = getCachedDesktopSession();
- const sessionToken =
+ const candidateToken = session.authenticated
+ ? session.sessionToken ?? cached?.sessionToken
+ : undefined;
+ let tokenStoredSecurely = true;
+ if (candidateToken) {
+ tokenStoredSecurely = await setDesktopSessionToken(candidateToken);
+ } else if (
session.authenticated &&
- !session.sessionToken &&
cached?.authenticated &&
- cached.user?.id === session.user?.id
- ? cached.sessionToken
- : session.sessionToken;
+ cached.user?.id !== session.user?.id
+ ) {
+ clearDesktopSessionToken();
+ }
+ const { sessionToken: _sessionToken, ...cachedSession } = session;
window.localStorage.setItem(
DESKTOP_SESSION_STORAGE_KEY,
- JSON.stringify(sessionToken ? { ...session, sessionToken } : session),
+ JSON.stringify(candidateToken && !tokenStoredSecurely ? { ...cachedSession, sessionToken: candidateToken } : cachedSession),
);
} catch {
// A session cache is an offline convenience and must never block login.
@@ -100,6 +135,7 @@ export const clearCachedDesktopSession = () => {
} catch {
// Ignore restricted storage contexts.
}
+ clearDesktopSessionToken();
};
export const getConfiguredDesktopApiBaseUrl = () => {
@@ -208,7 +244,7 @@ const isDesktopAuthenticationRequest = (path: string) =>
const request = async <T>(path: string, init?: RequestInit): Promise<T> => {
const headers = new Headers(init?.headers);
const isDesktop = Boolean(window.edgeeverDesktop?.isAvailable);
- const sessionToken = isDesktop ? getCachedDesktopSession()?.sessionToken : undefined;
+ const sessionToken = isDesktop ? getDesktopSessionToken() : undefined;
if (isDesktop && desktopSessionRejected && !isDesktopAuthenticationRequest(path)) {
throw new ApiRequestError("Authentication required", 401, "unauthorized");
@@ -253,6 +289,19 @@ const request = async <T>(path: string, init?: RequestInit): Promise<T> => {
}
const body = await response.json() as T;
+ if (
+ isDesktop &&
+ path === "/api/v1/auth/session" &&
+ sessionToken &&
+ body &&
+ typeof body === "object" &&
+ "authenticated" in body &&
+ body.authenticated === false
+ ) {
+ clearCachedDesktopSession();
+ desktopSessionRejected = true;
+ window.dispatchEvent(new CustomEvent("edgeever:unauthorized"));
+ }
if (path === "/api/v1/auth/login") {
desktopSessionRejected = false;
}
diff --git a/apps/web/src/vite-env.d.ts b/apps/web/src/vite-env.d.ts
index ddf88e27..b500ed92 100644
--- a/apps/web/src/vite-env.d.ts
+++ b/apps/web/src/vite-env.d.ts
@@ -12,6 +12,9 @@ interface EdgeEverDesktopBridge {
isAvailable: boolean;
apiBaseUrl: string;
setApiBaseUrl(value: string): Promise<string>;
+ getSessionToken(): string;
+ setSessionToken(value: string): Promise<{ stored: boolean }>;
+ clearSessionToken(): Promise<{ stored: false }>;
sidecarStatus(): Promise<{ available: boolean; path: string; scope: string }>;
setAccountScope(accountId: string | null): Promise<{ ready: true; scope: string }>;
updateStatus(): Promise<{ state: "idle" | "available" | "downloaded" }>;