@@ -28,7 +28,6 @@
     "@zip.js/zip.js": "2.7.62",
     "electron-context-menu": "4.1.2",
     "electron-log": "^5",
-    "electron-store": "11.0.2",
     "electron-updater": "6.8.9",
     "lighthouse": "13.4.1"
   },
 
@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test"
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { createSettingsStore } from "./store"
+
+const dir = () => mkdtempSync(path.join(tmpdir(), "opencode-settings-"))
+
+describe("settings store", () => {
+  test("reads the tab-indented file electron-store wrote and rewrites it in the same shape", () => {
+    const file = path.join(dir(), "opencode.settings")
+    writeFileSync(file, JSON.stringify({ windowIds: ["a"], backgroundColor: "#121212" }, null, "\t"))
+    const store = createSettingsStore(file)
+    expect(store.get("windowIds")).toEqual(["a"])
+    store.set("backgroundColor", "#ffffff")
+    expect(readFileSync(file, "utf8")).toBe(
+      JSON.stringify({ windowIds: ["a"], backgroundColor: "#ffffff" }, null, "\t"),
+    )
+    expect(createSettingsStore(file).get("backgroundColor")).toBe("#ffffff")
+  })
+
+  test("starts empty without a file and creates it on the first write", () => {
+    const file = path.join(dir(), "nested", "opencode.updater")
+    const store = createSettingsStore(file)
+    expect(store.get("ready")).toBeUndefined()
+    expect(existsSync(file)).toBe(false)
+    store.set("ready", { version: "1.0.0" })
+    expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({ ready: { version: "1.0.0" } })
+    store.delete("ready")
+    expect(store.get("ready")).toBeUndefined()
+    expect(readFileSync(file, "utf8")).toBe("{}")
+  })
+
+  test("sets an unreadable file aside instead of failing", () => {
+    const file = path.join(dir(), "opencode.settings")
+    writeFileSync(file, "{ not json")
+    const store = createSettingsStore(file)
+    expect(store.get("anything")).toBeUndefined()
+    expect(existsSync(`${file}.corrupt`)).toBe(true)
+    store.set("firstLaunchOnboardingComplete", true)
+    expect(JSON.parse(readFileSync(file, "utf8"))).toEqual({ firstLaunchOnboardingComplete: true })
+  })
+
+  test("rejects undefined like electron-store did", () => {
+    const store = createSettingsStore(path.join(dir(), "opencode.settings"))
+    expect(() => store.set("key", undefined)).toThrow(TypeError)
+  })
+})
@@ -1,28 +1,62 @@
-import Store from "electron-store"
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import path from "node:path"
 import electron from "electron"
 
 import { SETTINGS_STORE } from "./keys"
 
-const cache = new Map<string, Store>()
+const cache = new Map<string, SettingsStore>()
+
+export type SettingsStore = ReturnType<typeof createSettingsStore>
 
 // Main-process settings only (onboarding, default server, window list, appearance, updater).
-// These are read synchronously before the storage layer exists and written on user action, so
-// electron-store's synchronous file write is acceptable here. Renderer state goes through
-// DesktopStorage instead.
+// These are read synchronously before the storage layer exists and written on user action, so a
+// synchronous whole-file write is acceptable here. Renderer state goes through DesktopStorage.
+//
+// The file is the tab-indented JSON object electron-store used to write, so existing profiles
+// (and older builds) read the same data.
 //
-// We cannot instantiate the electron-store at module load time because
-// module import hoisting causes this to run before app.setPath("userData", ...)
-// in index.ts has executed, which would result in files being written to the default directory
-// (e.g. bad: %APPDATA%\@opencode\desktop\opencode.settings vs good: %APPDATA%\ai.opencode.desktop.dev\opencode.settings).
+// We cannot instantiate the store at module load time because module import hoisting causes this
+// to run before app.setPath("userData", ...) has executed, which would result in files being
+// written to the default directory (e.g. bad: %APPDATA%\@opencode\desktop\opencode.settings vs
+// good: %APPDATA%\ai.opencode.desktop.dev\opencode.settings).
 export function getStore(name = SETTINGS_STORE) {
   const cached = cache.get(name)
   if (cached) return cached
-  const next = new Store({
-    name,
-    cwd: electron.app.getPath("userData"),
-    fileExtension: "",
-    accessPropertiesByDotNotation: false,
-  })
+  const next = createSettingsStore(path.join(electron.app.getPath("userData"), name))
   cache.set(name, next)
   return next
 }
+
+export function createSettingsStore(file: string) {
+  let data = read(file)
+  const write = () => {
+    mkdirSync(path.dirname(file), { recursive: true })
+    writeFileSync(`${file}.tmp`, JSON.stringify(data, null, "\t"))
+    renameSync(`${file}.tmp`, file)
+  }
+  return {
+    path: file,
+    get: (key: string): unknown => data[key],
+    set: (key: string, value: unknown) => {
+      if (value === undefined) throw new TypeError(`Use \`delete()\` to clear values: ${key}`)
+      data = { ...data, [key]: value }
+      write()
+    },
+    delete: (key: string) => {
+      data = Object.fromEntries(Object.entries(data).filter(([item]) => item !== key))
+      write()
+    },
+  }
+}
+
+// A missing file is an empty store. An unreadable one is set aside instead of blocking startup.
+function read(file: string): Record<string, unknown> {
+  if (!existsSync(file)) return {}
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(file, "utf8"))
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : {}
+  } catch {
+    renameSync(file, `${file}.corrupt`)
+    return {}
+  }
+}