feat: Completed the reconstruction of the system settings page

feat: Add API security protection
fix: Fix a large number of known issues

Author: Amery2010

.env.example

@@ -13,7 +13,7 @@ BYOK_ALLOW_EPHEMERAL_KEY="false"
 DEPLOYMENT_MODE="local"
 ALLOW_LOCAL_NETWORK_PROXY=""
 # Trust x-forwarded-* and related proxy headers only when your platform strips spoofed values.
-TRUST_PROXY_HEADERS="true"
+TRUST_PROXY_HEADERS="false"
 
 # Optional in local mode, required in hosted mode.
 # RATE_LIMIT_STORE, DOCUMENT_PARSE_JOB_STORE, and PLUGIN_REGISTRY_STORE support memory or upstash.

docs/environment-variables.md

@@ -83,8 +83,8 @@ registry lookups survive across instances.
 
 ## Upload Limits
 
-| Variable                    | Purpose                                                                                     |
-| --------------------------- | ------------------------------------------------------------------------------------------- |
+| Variable                    | Purpose                                                                                       |
+| --------------------------- | --------------------------------------------------------------------------------------------- |
 | `MAX_ATTACHMENT_FILE_BYTES` | Maximum chat attachment file size in bytes. Defaults to `10485760` and is clamped internally. |
 
 ## Public URLs

src/__tests__/appConfig.test.ts

@@ -36,6 +36,7 @@ describe("app config normalization", () => {
     expect(normalizeChatConfig({})).toEqual(DEFAULT_CHAT_CONFIG);
     expect(normalizeSystemSettings({})).toEqual(DEFAULT_SYSTEM_SETTINGS);
     expect(DEFAULT_SYSTEM_SETTINGS.enableHtmlVisualPrompt).toBe(true);
+    expect(DEFAULT_SYSTEM_SETTINGS.personality).toBe("default");
   });
 
   it("migrates legacy reasoning booleans to reasoning modes", () => {
@@ -96,4 +97,21 @@ describe("app config normalization", () => {
       DEFAULT_SYSTEM_SETTINGS.fontSize,
     );
   });
+
+  it("normalizes system personality without legacy reply style fields", () => {
+    expect(normalizeSystemSettings({ personality: "efficient" })).toMatchObject(
+      {
+        personality: "efficient",
+      },
+    );
+    expect(normalizeSystemSettings({ personality: "verbose" })).toMatchObject({
+      personality: DEFAULT_SYSTEM_SETTINGS.personality,
+    });
+    expect(
+      normalizeSystemSettings({ replyStyle: "concise" }),
+    ).not.toHaveProperty("replyStyle");
+    expect(normalizeSystemSettings({ replyTone: "direct" })).not.toHaveProperty(
+      "replyTone",
+    );
+  });
 });

src/__tests__/byokServices.test.ts

@@ -76,6 +76,16 @@ vi.mock("@/lib/utils/voiceModels", async () =>
   vi.importActual("../lib/utils/voiceModels"),
 );
 
+vi.mock("../lib/api/client", async () => {
+  const actual = await vi.importActual("../lib/api/client");
+  return {
+    ...actual,
+    signedApiFetch: vi.fn((input: RequestInfo | URL, init?: RequestInit) =>
+      fetch(input, init),
+    ),
+  };
+});
+
 const providerWithoutLocalKey: ModelProvider = {
   id: "env-provider",
   name: "Env Gemini",

src/__tests__/chatPanelUrlState.test.ts

@@ -7,11 +7,11 @@ import {
 describe("chat panel URL state", () => {
   it("parses valid panel and settings tab query params", () => {
     const state = parseChatPanelUrlState(
-      new URLSearchParams("panel=settings&settingsTab=memory&keep=1"),
+      new URLSearchParams("panel=settings&settingsTab=about&keep=1"),
     );
 
     expect(state.panel).toBe("settings");
-    expect(state.settingsTab).toBe("memory");
+    expect(state.settingsTab).toBe("about");
     expect(state.needsReplace).toBe(false);
   });
 

src/__tests__/chatServiceToolConfirmation.test.ts

@@ -42,6 +42,16 @@ vi.mock("../lib/byok/client", () => ({
   fetchWithByokRetry: vi.fn((requestFactory) => requestFactory()),
 }));
 
+vi.mock("../lib/api/client", async () => {
+  const actual = await vi.importActual("../lib/api/client");
+  return {
+    ...actual,
+    signedApiFetch: vi.fn((input: RequestInfo | URL, init?: RequestInit) =>
+      fetch(input, init),
+    ),
+  };
+});
+
 vi.mock("@/lib/plugin/resolve", () => ({
   getEnabledPluginFunctions: vi.fn((plugin: Plugin) => plugin.functions || []),
 }));

src/__tests__/chatShellA11y.test.ts

@@ -33,7 +33,7 @@ describe("chat shell accessibility", () => {
     expect(sidebar).toContain("env(safe-area-inset-bottom)");
   });
 
-  it("isolates the main chat region while the mobile sidebar drawer is open", () => {
+  it("isolates the main chat region while the non-desktop sidebar drawer is open", () => {
     const chatApp = readFileSync(
       resolve(process.cwd(), "src/components/app/ChatApp.tsx"),
       "utf8",
@@ -43,6 +43,13 @@ describe("chat shell accessibility", () => {
       "utf8",
     );
 
+    expect(chatApp).toContain("isNonDesktopViewport");
+    expect(chatApp).toContain("window.innerWidth < 1024");
+    expect(chatApp).toContain(
+      "const isSidebarDrawerOpen = isSidebarOpen && isNonDesktopViewport",
+    );
+    expect(chatApp).toContain("md:pl-16 lg:pl-0");
+    expect(chatApp).not.toContain("backdrop-blur-[1px]");
     expect(chatApp).toContain("mainInertProps");
     expect(chatApp).toContain("inert");
     expect(chatApp).toContain("aria-hidden");
@@ -51,4 +58,36 @@ describe("chat shell accessibility", () => {
     expect(sidebar).toContain("handleSidebarKeyDown");
     expect(sidebar).toContain("restoreFocusRef");
   });
+
+  it("keeps mobile header icon buttons keyboard-focus visible", () => {
+    const chatApp = readFileSync(
+      resolve(process.cwd(), "src/components/app/ChatApp.tsx"),
+      "utf8",
+    );
+
+    expect(chatApp).toContain(
+      "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+    );
+    expect(chatApp).toContain(
+      '<MessageSquarePlus size={16} aria-hidden="true" />',
+    );
+  });
+
+  it("contains workspace settings scrolling on small viewports", () => {
+    const modal = readFileSync(
+      resolve(
+        process.cwd(),
+        "src/components/layout/WorkspaceSettingsModal.tsx",
+      ),
+      "utf8",
+    );
+
+    expect(modal).toContain("document.body.style.overflow");
+    expect(modal).toContain("100dvh");
+    expect(modal).toContain("overscroll-contain");
+    expect(modal).toContain("env(safe-area-inset-bottom)");
+    expect(modal).toContain("min-w-0 truncate");
+    expect(modal).toContain("title={plugin.title}");
+    expect(modal).toContain("title={col.name}");
+  });
 });

src/__tests__/clearAppData.test.ts

@@ -21,8 +21,19 @@ const {
   const removeMock = vi.fn(() => Promise.resolve());
   return {
     appDbMock: {
-      getItem: vi.fn(),
-      clear: vi.fn(() => Promise.resolve()),
+      getItem: vi.fn(async (key: string) => {
+        void key;
+        return undefined as unknown;
+      }),
+      setItem: vi.fn(async (key: string, value: unknown) => {
+        void key;
+        void value;
+      }),
+      removeItem: vi.fn(async (key: string) => {
+        void key;
+      }),
+      keys: vi.fn(async (): Promise<string[]> => []),
+      clear: vi.fn(async () => undefined),
     },
     dirMock: vi.fn(() => ({
       exists: vi.fn(() => Promise.resolve(true)),
@@ -60,9 +71,21 @@ vi.mock("../store/storage/storageConfig", () => ({
 
 vi.mock("../lib/byok/client", () => ({
   encryptSecret: encryptSecretMock,
+  fetchWithByokRetry: vi.fn((requestFactory) => requestFactory()),
 }));
 
-const { clearBrowserAppData } = await import("../lib/data/clearAppData");
+vi.mock("../lib/api/client", async () => {
+  const actual = await vi.importActual("../lib/api/client");
+  return {
+    ...actual,
+    signedApiFetch: vi.fn((input: RequestInfo | URL, init?: RequestInit) =>
+      fetch(input, init),
+    ),
+  };
+});
+
+const { clearBrowserAppData, clearBrowserAppDataSources } =
+  await import("../lib/data/clearAppData");
 const { deleteOPFSDirectory } = await import("../utils/opfs");
 
 const ragConfig: RAGConfig = {
@@ -159,6 +182,93 @@ describe("clear app data", () => {
     expect(appDbMock.clear).toHaveBeenCalled();
   });
 
+  it("clears cache metadata without clearing user settings or stores", async () => {
+    appDbMock.getItem.mockResolvedValueOnce(
+      JSON.stringify({
+        state: {
+          marketPlugins: [{ id: "cached-plugin" }],
+          marketPluginsTimestamp: 123,
+          marketAgents: [{ identifier: "cached-agent" }],
+          marketAgentsTimestamp: 456,
+          marketAgentsLocale: "zh",
+          skillCatalogs: { en: { skills: [] } },
+          skillCatalogTimestamps: { en: 789 },
+          skillDefinitions: { "en:test.json": { id: "test" } },
+          skillDefinitionTimestamps: { "en:test.json": 999 },
+          modelMetadata: { "gpt-test": { id: "gpt-test" } },
+          modelMetadataTimestamp: 321,
+          installedPlugins: [{ id: "keep-plugin" }],
+        },
+        version: 4,
+      }),
+    );
+
+    await clearBrowserAppDataSources({
+      sources: ["cache"],
+      rag: ragConfig,
+    });
+
+    expect(appDbMock.clear).not.toHaveBeenCalled();
+    expect(localforageClearMock).not.toHaveBeenCalled();
+    expect(appDbMock.removeItem).not.toHaveBeenCalled();
+    expect(appDbMock.setItem).toHaveBeenCalledWith(
+      "neo-chat-settings",
+      expect.stringContaining('"installedPlugins":[{"id":"keep-plugin"}]'),
+    );
+    const saved = JSON.parse(appDbMock.setItem.mock.calls[0][1] as string);
+    expect(saved.state).toMatchObject({
+      marketPlugins: [],
+      marketPluginsTimestamp: 0,
+      marketAgents: [],
+      marketAgentsTimestamp: 0,
+      marketAgentsLocale: "",
+      skillCatalogs: {},
+      skillCatalogTimestamps: {},
+      skillDefinitions: {},
+      skillDefinitionTimestamps: {},
+      modelMetadata: {},
+      modelMetadataTimestamp: 0,
+    });
+  });
+
+  it("clears chat metadata and per-session message records when requested", async () => {
+    appDbMock.keys.mockResolvedValueOnce([
+      "neo-chat-storage",
+      "session_messages_a",
+      "session_messages_b",
+      "unrelated",
+    ]);
+
+    await clearBrowserAppDataSources({
+      sources: ["chats"],
+      rag: ragConfig,
+    });
+
+    expect(appDbMock.removeItem).toHaveBeenCalledWith("neo-chat-storage");
+    expect(appDbMock.removeItem).toHaveBeenCalledWith("session_messages_a");
+    expect(appDbMock.removeItem).toHaveBeenCalledWith("session_messages_b");
+    expect(appDbMock.removeItem).not.toHaveBeenCalledWith("unrelated");
+    expect(appDbMock.clear).not.toHaveBeenCalled();
+  });
+
+  it("clears knowledge metadata, vectors, and OPFS knowledge files when requested", async () => {
+    await clearBrowserAppDataSources({
+      sources: ["knowledge"],
+      rag: ragConfig,
+    });
+
+    expect(fetch).toHaveBeenCalledWith(
+      "/api/rag/delete",
+      expect.objectContaining({
+        method: "POST",
+        body: expect.stringContaining('"namespace":"collection-1"'),
+      }),
+    );
+    expect(dirMock).toHaveBeenCalledWith("knowledge-base");
+    expect(appDbMock.removeItem).toHaveBeenCalledWith("knowledge-storage");
+    expect(appDbMock.clear).not.toHaveBeenCalled();
+  });
+
   it("rejects unsafe OPFS directory paths", async () => {
     await deleteOPFSDirectory("../secret");
 

src/__tests__/clientApi.test.ts

@@ -1,11 +1,18 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import {
+  clearApiProofSessionCache,
   getResponseErrorMessage,
   readJsonResponse,
   readJsonResponseOrThrow,
+  signedApiFetch,
 } from "../lib/api/client";
 
 describe("client API response helpers", () => {
+  afterEach(() => {
+    clearApiProofSessionCache();
+    vi.restoreAllMocks();
+  });
+
   it("parses JSON responses and returns null for empty or malformed bodies", async () => {
     await expect(
       readJsonResponse<{ ok: boolean }>(Response.json({ ok: true })),
@@ -36,4 +43,71 @@ describe("client API response helpers", () => {
       getResponseErrorMessage(new Response("<html></html>"), "Fallback"),
     ).resolves.toBe("Fallback");
   });
+
+  it("signs protected API requests with a cached request proof session", async () => {
+    const fetchMock = vi
+      .spyOn(globalThis, "fetch")
+      .mockImplementation(
+        async (input: RequestInfo | URL, init?: RequestInit) => {
+          if (String(input) === "/api/request-proof/session") {
+            return Response.json({
+              enabled: true,
+              clientKey: "dGVzdC1jbGllbnQtcHJvb2Yta2V5",
+              expiresAt: Date.now() + 600_000,
+              serverTime: Date.now(),
+              windowMs: 60_000,
+            });
+          }
+
+          return Response.json({
+            ok: true,
+            headers: Object.fromEntries(new Headers(init?.headers).entries()),
+            body: init?.body,
+            signal: init?.signal ? "present" : "missing",
+          });
+        },
+      );
+    const controller = new AbortController();
+
+    const response = await signedApiFetch("/api/chat", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ok: true }),
+      signal: controller.signal,
+    });
+    const data = await response.json();
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(data.headers["content-type"]).toBe("application/json");
+    expect(data.headers["x-neo-api-proof-timestamp"]).toBeTruthy();
+    expect(data.headers["x-neo-api-proof-nonce"]).toBeTruthy();
+    expect(data.headers["x-neo-api-proof-signature"]).toBeTruthy();
+    expect(data.body).toBe(JSON.stringify({ ok: true }));
+    expect(data.signal).toBe("present");
+
+    await signedApiFetch("/api/search", { method: "POST" });
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+  });
+
+  it("does not add proof headers when the server reports proof disabled", async () => {
+    vi.spyOn(globalThis, "fetch").mockImplementation(
+      async (input: RequestInfo | URL, init?: RequestInit) => {
+        if (String(input) === "/api/request-proof/session") {
+          return Response.json({
+            enabled: false,
+            serverTime: Date.now(),
+          });
+        }
+
+        return Response.json({
+          headers: Object.fromEntries(new Headers(init?.headers).entries()),
+        });
+      },
+    );
+
+    const response = await signedApiFetch("/api/chat", { method: "POST" });
+    const data = await response.json();
+
+    expect(data.headers["x-neo-api-proof-signature"]).toBeUndefined();
+  });
 });