@neurocode-ai/desktop 1.18.8

package/src/main/store-cleanup.ts

@@ -0,0 +1,94 @@
+import { readdir, readFile, rm, stat } from "node:fs/promises"
+import { join } from "node:path"
+
+const EMPTY_STORE_MAX_BYTES = 128
+const DRAFT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000
+const DRAFT_KEEP_RECENT = 100
+
+type StoreKind = "draft" | "workspace"
+type StoreCandidate = {
+  name: string
+  path: string
+  kind: StoreKind
+  modified: number
+  empty: boolean
+}
+
+export async function cleanupStoreFiles(userDataPath: string, now = Date.now()) {
+  const entries = await readdir(userDataPath, { withFileTypes: true }).catch(() => [])
+  const candidates = (
+    await Promise.all(
+      entries
+        .filter((entry) => entry.isFile())
+        .map(async (entry) => {
+          const kind = storeKind(entry.name)
+          if (!kind) return
+
+          const file = join(userDataPath, entry.name)
+          const stats = await stat(file).catch(() => undefined)
+          if (!stats?.isFile()) return
+
+          return {
+            name: entry.name,
+            path: file,
+            kind,
+            modified: stats.mtimeMs,
+            empty: await isEmptyStore(file, stats.size),
+          }
+        }),
+    )
+  ).filter((candidate) => !!candidate)
+
+  const stale = new Set<StoreCandidate>()
+  for (const candidate of candidates) {
+    if (candidate.empty) stale.add(candidate)
+    if (candidate.kind === "draft" && now - candidate.modified > DRAFT_RETENTION_MS) stale.add(candidate)
+  }
+
+  candidates
+    .filter((candidate) => candidate.kind === "draft" && !candidate.empty)
+    .sort((a, b) => b.modified - a.modified)
+    .slice(DRAFT_KEEP_RECENT)
+    .forEach((candidate) => stale.add(candidate))
+
+  const deleted = await Promise.all(
+    [...stale].map(async (candidate) => {
+      await rm(candidate.path, { force: true })
+      return candidate.name
+    }),
+  )
+
+  return { scanned: candidates.length, deleted }
+}
+
+export async function deleteStoreFileIfEmpty(userDataPath: string, name: string) {
+  if (!storeKind(name)) return false
+
+  const file = join(userDataPath, name)
+  const stats = await stat(file).catch(() => undefined)
+  if (!stats?.isFile()) return false
+  if (!(await isEmptyStore(file, stats.size))) return false
+
+  await rm(file, { force: true })
+  return true
+}
+
+function storeKind(name: string): StoreKind | undefined {
+  if (/^opencode\.draft\..+\.dat$/.test(name)) return "draft"
+  if (/^opencode\.workspace\..+\.dat$/.test(name)) return "workspace"
+}
+
+async function isEmptyStore(file: string, size: number) {
+  if (size > EMPTY_STORE_MAX_BYTES) return false
+
+  const raw = await readFile(file, "utf8").catch(() => undefined)
+  if (raw === undefined) return false
+  if (raw.trim() === "") return true
+
+  try {
+    const parsed = JSON.parse(raw) as unknown
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && Object.keys(parsed).length === 0
+  } catch {
+    return false
+  }
+}

package/src/main/store-keys.ts

@@ -0,0 +1,7 @@
+export const SETTINGS_STORE = "neurocode.settings"
+export const DEFAULT_SERVER_URL_KEY = "defaultServerUrl"
+export const FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY = "firstLaunchOnboardingComplete"
+export const OLD_LAYOUT_ELIGIBLE_KEY = "oldLayoutEligible"
+export const WSL_SERVERS_KEY = "wslServers"
+export const PINCH_ZOOM_ENABLED_KEY = "pinchZoomEnabled"
+export const WINDOW_IDS_KEY = "windowIds"

package/src/main/store.ts

@@ -0,0 +1,35 @@
+import Store from "electron-store"
+import electron from "electron"
+import { rmSync } from "node:fs"
+import { join } from "node:path"
+
+import { SETTINGS_STORE } from "./store-keys"
+import { deleteStoreFileIfEmpty } from "./store-cleanup"
+
+const cache = new Map<string, Store>()
+
+// 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-ai\desktop\neurocode.settings vs good: %APPDATA%\ai.neurocode.desktop.dev\neurocode.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,
+  })
+  cache.set(name, next)
+  return next
+}
+
+export async function removeStoreFileIfEmpty(name: string) {
+  if (await deleteStoreFileIfEmpty(electron.app.getPath("userData"), name)) cache.delete(name)
+}
+
+export function removeStoreFile(name: string) {
+  rmSync(join(electron.app.getPath("userData"), name), { force: true })
+  cache.delete(name)
+}

package/src/main/unresponsive.ts

@@ -0,0 +1,70 @@
+import type { BrowserWindow } from "electron"
+import { write as writeLog } from "./logging"
+import { safeWindowURL } from "./window-state"
+
+const sampleInterval = 1000
+const samplePeriod = 15000
+
+export function createUnresponsiveSampler(win: BrowserWindow, name: string) {
+  let sampleTimer: ReturnType<typeof setTimeout> | undefined
+  let stopTimer: ReturnType<typeof setTimeout> | undefined
+  let sampling = false
+  const samples = new Map<string, number>()
+
+  const active = () => sampling && !win.isDestroyed() && !win.webContents.isDestroyed()
+  const clearTimers = () => {
+    if (sampleTimer) clearTimeout(sampleTimer)
+    if (stopTimer) clearTimeout(stopTimer)
+    sampleTimer = undefined
+    stopTimer = undefined
+  }
+
+  const schedule = () => {
+    sampleTimer = setTimeout(() => {
+      void collect()
+    }, sampleInterval)
+  }
+
+  const collect = async () => {
+    if (!active()) return
+    const stack = await win.webContents.mainFrame.collectJavaScriptCallStack().catch((error) => {
+      writeLog("window", "failed to collect unresponsive sample", { window: name, error }, "error")
+      return undefined
+    })
+    if (!active()) return
+    if (stack) samples.set(stack, (samples.get(stack) ?? 0) + 1)
+    schedule()
+  }
+
+  const stopAndFlush = () => {
+    const wasSampling = sampling
+    sampling = false
+    clearTimers()
+    if (samples.size === 0) return wasSampling
+
+    const entries = [...samples.entries()].sort((a, b) => b[1] - a[1])
+    const total = entries.reduce((sum, entry) => sum + entry[1], 0)
+    const message = [
+      "renderer unresponsive samples",
+      `Window: ${name}`,
+      `URL: ${safeWindowURL(win)}`,
+      ...entries.map((entry) => `<${entry[1]}> ${entry[0]}`),
+      `Total Samples: ${total}`,
+    ].join("\n")
+    writeLog("window", message, undefined, "error")
+    samples.clear()
+    return wasSampling
+  }
+
+  const start = () => {
+    if (sampling || win.isDestroyed() || win.webContents.isDestroyed() || win.webContents.isDevToolsOpened()) return
+    sampling = true
+    samples.clear()
+    schedule()
+    stopTimer = setTimeout(stopAndFlush, samplePeriod)
+  }
+
+  win.on("closed", stopAndFlush)
+
+  return { start, stopAndFlush }
+}

package/src/main/updater-controller.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test"
+import { createUpdaterController, type UpdaterBackend, type UpdaterReadyRecord } from "./updater-controller"
+
+function setup(input?: { currentVersion?: string; ready?: UpdaterReadyRecord }) {
+  const calls: string[] = []
+  const backend: UpdaterBackend = {
+    async checkForUpdates() {
+      calls.push("check")
+      return { isUpdateAvailable: true, updateInfo: { version: "2.0.0" } }
+    },
+    async downloadUpdate() {
+      calls.push("download")
+    },
+    quitAndInstall() {
+      calls.push("install")
+    },
+  }
+  let ready = input?.ready
+  const controller = createUpdaterController({
+    enabled: true,
+    currentVersion: input?.currentVersion ?? "1.0.0",
+    backend,
+    persistence: {
+      get: () => ready,
+      set: (value) => {
+        ready = value
+      },
+      clear: () => {
+        ready = undefined
+      },
+    },
+    stop: async () => {
+      calls.push("stop")
+    },
+  })
+  return { controller, calls, getReady: () => ready }
+}
+
+describe("updater controller", () => {
+  test("checks, downloads, persists, and publishes one authoritative ready state", async () => {
+    const app = setup()
+    const states: ReturnType<typeof app.controller.getState>[] = []
+    app.controller.subscribe((state) => states.push(state))
+
+    await app.controller.start()
+
+    expect(app.calls).toEqual(["check", "download"])
+    expect(app.getReady()).toEqual({ version: "2.0.0" })
+    expect(states.map((state) => state.status)).toEqual(["idle", "checking", "downloading", "ready"])
+    expect(app.controller.getState()).toEqual({ status: "ready", version: "2.0.0" })
+  })
+
+  test("revalidates a persisted target through the updater cache on launch", async () => {
+    const app = setup({ ready: { version: "2.0.0" } })
+
+    await app.controller.start()
+
+    expect(app.calls).toEqual(["check", "download"])
+    expect(app.controller.getState()).toEqual({ status: "ready", version: "2.0.0" })
+  })
+
+  test("clears a target already installed before checking", async () => {
+    const app = setup({ currentVersion: "2.0.0", ready: { version: "2.0.0" } })
+
+    await app.controller.start()
+
+    expect(app.getReady()).toBeUndefined()
+    expect(app.calls).toEqual(["check"])
+  })
+
+  test("coalesces concurrent checks", async () => {
+    const app = setup()
+
+    await Promise.all([app.controller.check(), app.controller.check(), app.controller.check()])
+
+    expect(app.calls).toEqual(["check", "download"])
+  })
+
+  test("returns to ready when quitAndInstall returns without exiting", async () => {
+    const app = setup()
+    await app.controller.start()
+
+    await app.controller.install()
+
+    expect(app.calls).toEqual(["check", "download", "stop", "install"])
+    expect(app.controller.getState()).toEqual({ status: "ready", version: "2.0.0" })
+  })
+
+  test("returns to ready when installation cannot start", async () => {
+    const app = setup()
+    await app.controller.start()
+
+    const failed = createUpdaterController({
+      enabled: true,
+      currentVersion: "1.0.0",
+      backend: {
+        checkForUpdates: async () => ({ isUpdateAvailable: true, updateInfo: { version: "2.0.0" } }),
+        downloadUpdate: async () => {},
+        quitAndInstall() {},
+      },
+      persistence: { get: () => undefined, set() {}, clear() {} },
+      stop: async () => {
+        throw new Error("stop failed")
+      },
+    })
+    await failed.start()
+
+    await expect(failed.install()).rejects.toThrow("stop failed")
+    expect(failed.getState()).toEqual({ status: "ready", version: "2.0.0" })
+  })
+})

package/src/main/updater-controller.ts

@@ -0,0 +1,97 @@
+import type { UpdaterState } from "@neurocode-ai/app/updater"
+
+export type { UpdaterState } from "@neurocode-ai/app/updater"
+
+export type UpdaterReadyRecord = { version: string }
+
+export type UpdaterBackend = {
+  checkForUpdates(): Promise<{ isUpdateAvailable?: boolean; updateInfo?: { version?: string } } | null | undefined>
+  downloadUpdate(): Promise<unknown>
+  quitAndInstall(): void
+}
+
+type UpdaterPersistence = {
+  get(): UpdaterReadyRecord | undefined | Promise<UpdaterReadyRecord | undefined>
+  set(value: UpdaterReadyRecord): void | Promise<void>
+  clear(): void | Promise<void>
+}
+
+export function createUpdaterController(input: {
+  enabled: boolean
+  currentVersion: string
+  backend: UpdaterBackend
+  persistence: UpdaterPersistence
+  stop: () => Promise<void>
+  log?: (message: string, data?: object) => void
+}) {
+  let state: UpdaterState = input.enabled ? { status: "idle" } : { status: "disabled" }
+  let pending: Promise<UpdaterState> | undefined
+  const listeners = new Set<(state: UpdaterState) => void>()
+
+  const transition = (next: UpdaterState) => {
+    input.log?.("updater state changed", { from: state.status, to: next.status })
+    state = next
+    listeners.forEach((listener) => listener(state))
+    return state
+  }
+
+  const check = () => {
+    if (!input.enabled) return Promise.resolve(state)
+    if (state.status === "ready") return Promise.resolve(state)
+    if (pending) return pending
+
+    pending = (async () => {
+      transition({ status: "checking" })
+      const result = await input.backend.checkForUpdates()
+      const version = result?.updateInfo?.version
+      if (!result?.isUpdateAvailable || !version || version === input.currentVersion) {
+        await input.persistence.clear()
+        return transition({ status: "up-to-date" })
+      }
+
+      transition({ status: "downloading", version })
+      await input.backend.downloadUpdate()
+      await input.persistence.set({ version })
+      return transition({ status: "ready", version })
+    })()
+      .catch((error) =>
+        transition({ status: "error", message: error instanceof Error ? error.message : String(error) }),
+      )
+      .finally(() => {
+        pending = undefined
+      })
+    return pending
+  }
+
+  return {
+    getState: () => state,
+    subscribe(listener: (state: UpdaterState) => void) {
+      listeners.add(listener)
+      listener(state)
+      return () => listeners.delete(listener)
+    },
+    async start() {
+      const ready = await input.persistence.get()
+      if (ready?.version === input.currentVersion) await input.persistence.clear()
+      return check()
+    },
+    check,
+    async install() {
+      if (state.status !== "ready") throw new Error("Update is not ready to install")
+      const version = state.version
+      transition({ status: "installing", version })
+      await input
+        .stop()
+        .then(() => {
+          input.backend.quitAndInstall()
+          transition({ status: "ready", version })
+        })
+        .catch((error) => {
+          transition({ status: "ready", version })
+          throw error
+        })
+    },
+  }
+}
+
+export type UpdaterController = ReturnType<typeof createUpdaterController>

package/src/main/updater-subscriptions.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test"
+import { createUpdaterSubscriptions } from "./updater-subscriptions"
+
+describe("updater subscriptions", () => {
+  test("replaces the previous renderer subscription on reload", () => {
+    const subscriptions = createUpdaterSubscriptions()
+    const disposed: string[] = []
+
+    subscriptions.set(1, () => disposed.push("first"))
+    subscriptions.set(1, () => disposed.push("second"))
+
+    expect(disposed).toEqual(["first"])
+    subscriptions.delete(1)
+    expect(disposed).toEqual(["first", "second"])
+  })
+})

package/src/main/updater-subscriptions.ts

@@ -0,0 +1,20 @@
+export function createUpdaterSubscriptions() {
+  const subscriptions = new Map<number, () => void>()
+
+  const remove = (id: number) => {
+    subscriptions.get(id)?.()
+    subscriptions.delete(id)
+  }
+
+  return {
+    set(id: number, unsubscribe: () => void) {
+      remove(id)
+      subscriptions.set(id, unsubscribe)
+    },
+    delete: remove,
+    clear() {
+      subscriptions.forEach((unsubscribe) => unsubscribe())
+      subscriptions.clear()
+    },
+  }
+}

package/src/main/updater.ts

@@ -0,0 +1,85 @@
+import { app, dialog } from "electron"
+import pkg from "electron-updater"
+import { UPDATER_ENABLED } from "./constants"
+import { createUpdaterController, type UpdaterReadyRecord } from "./updater-controller"
+import { getLogger } from "./logging"
+import { getStore } from "./store"
+import { setAppQuitting } from "./windows"
+
+const { autoUpdater } = pkg
+const key = "ready"
+
+export function setupAutoUpdater(stop: () => Promise<void>) {
+  const logger = getLogger()
+  autoUpdater.logger = logger
+  autoUpdater.channel = "latest"
+  autoUpdater.allowPrerelease = false
+  autoUpdater.allowDowngrade = true
+  autoUpdater.autoDownload = false
+  autoUpdater.autoInstallOnAppQuit = false
+  logger.log("auto updater configured", {
+    channel: autoUpdater.channel,
+    allowPrerelease: autoUpdater.allowPrerelease,
+    allowDowngrade: autoUpdater.allowDowngrade,
+    currentVersion: app.getVersion(),
+  })
+
+  const store = getStore("neurocode.updater")
+  return createUpdaterController({
+    enabled: UPDATER_ENABLED,
+    currentVersion: app.getVersion(),
+    backend: {
+      checkForUpdates: () => autoUpdater.checkForUpdates(),
+      downloadUpdate: () => autoUpdater.downloadUpdate(),
+      quitAndInstall: () => {
+        // quitAndInstall closes all windows before emitting before-quit, so
+        // flag the quit first to keep window ids persisted for restore.
+        setAppQuitting()
+        try {
+          autoUpdater.quitAndInstall()
+        } catch (error) {
+          // The install failed and the app keeps running; clear the flag so
+          // deliberate window closes prune ids again.
+          setAppQuitting(false)
+          throw error
+        }
+      },
+    },
+    persistence: {
+      get() {
+        const value = store.get(key)
+        if (!value || typeof value !== "object" || !("version" in value) || typeof value.version !== "string") return
+        return { version: value.version } satisfies UpdaterReadyRecord
+      },
+      set: (value) => store.set(key, value),
+      clear: () => store.delete(key),
+    },
+    stop,
+    log: (message, data) => logger.log(message, data),
+  })
+}
+
+export async function showUpdaterDialog(controller: ReturnType<typeof setupAutoUpdater>, alertOnFail: boolean) {
+  const state = await controller.check()
+  if (state.status === "error") {
+    if (!alertOnFail) return
+    await dialog.showMessageBox({ type: "error", message: "Update check failed.", title: "Update Error" })
+    return
+  }
+  if (state.status === "up-to-date") {
+    if (!alertOnFail) return
+    await dialog.showMessageBox({ type: "info", message: "You're up to date.", title: "No Updates" })
+    return
+  }
+  if (state.status !== "ready") return
+
+  const response = await dialog.showMessageBox({
+    type: "info",
+    message: `Update ${state.version} downloaded. Restart now?`,
+    title: "Update Ready",
+    buttons: ["Restart", "Later"],
+    defaultId: 0,
+    cancelId: 1,
+  })
+  if (response.response === 0) await controller.install()
+}

package/src/main/window-registry.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "bun:test"
+import { createWindowRegistry } from "./window-registry"
+
+function setup(initial: unknown = []) {
+  const state = { stored: initial }
+  const cleaned: string[] = []
+  const registry = createWindowRegistry<{ name: string }>({
+    read: () => state.stored,
+    write: (ids) => {
+      state.stored = ids
+    },
+    cleanup: (id) => cleaned.push(id),
+  })
+  return { registry, state, cleaned }
+}
+
+describe("window registry", () => {
+  test("restores persisted ids and ignores malformed entries", () => {
+    expect(setup(["a", "", 42, "b"]).registry.persisted()).toEqual(["a", "b"])
+    expect(setup("junk").registry.persisted()).toEqual([])
+    expect(setup(undefined).registry.persisted()).toEqual([])
+  })
+
+  test("registers windows and persists each id once", () => {
+    const app = setup()
+    app.registry.register("a", { name: "a" })
+    app.registry.register("a", { name: "a" })
+    app.registry.register("b", { name: "b" })
+    expect(app.state.stored).toEqual(["a", "b"])
+  })
+
+  test("forgets a deliberately closed window while others remain open", () => {
+    const app = setup()
+    app.registry.register("a", { name: "a" })
+    app.registry.register("b", { name: "b" })
+    app.registry.closed("a")
+    expect(app.state.stored).toEqual(["b"])
+    expect(app.cleaned).toEqual(["a"])
+  })
+
+  test("keeps the id when the last window closes so relaunch restores it", () => {
+    const app = setup()
+    app.registry.register("a", { name: "a" })
+    app.registry.closed("a")
+    expect(app.state.stored).toEqual(["a"])
+    expect(app.cleaned).toEqual([])
+
+    const restarted = createWindowRegistry<{ name: string }>({
+      read: () => app.state.stored,
+      write: (ids) => {
+        app.state.stored = ids
+      },
+      cleanup: () => {},
+    })
+    expect(restarted.persisted()).toEqual(["a"])
+  })
+
+  test("keeps every id when windows close during quit", () => {
+    const app = setup()
+    app.registry.register("a", { name: "a" })
+    app.registry.register("b", { name: "b" })
+    app.registry.setQuitting()
+    app.registry.closed("a")
+    app.registry.closed("b")
+    expect(app.state.stored).toEqual(["a", "b"])
+    expect(app.cleaned).toEqual([])
+  })
+
+  test("tracks the last focused window and falls back on close", () => {
+    const app = setup()
+    app.registry.register("a", { name: "a" })
+    app.registry.register("b", { name: "b" })
+    app.registry.focused("a")
+    expect(app.registry.lastFocused()).toEqual({ name: "a" })
+    app.registry.closed("a")
+    expect(app.registry.lastFocused()).toEqual({ name: "b" })
+    app.registry.closed("b")
+    expect(app.registry.lastFocused()).toBeUndefined()
+  })
+
+  test("resumes forgetting closed windows after the quit flag resets", () => {
+    const app = setup()
+    app.registry.register("a", { name: "a" })
+    app.registry.register("b", { name: "b" })
+    app.registry.setQuitting()
+    app.registry.setQuitting(false)
+    app.registry.closed("a")
+    expect(app.state.stored).toEqual(["b"])
+    expect(app.cleaned).toEqual(["a"])
+  })
+})

package/src/main/window-registry.ts

@@ -0,0 +1,47 @@
+// Tracks open windows and the persisted window id list used to restore
+// windows (and their per-window persisted state) across app launches.
+export function createWindowRegistry<W>(persistence: {
+  read: () => unknown
+  write: (ids: string[]) => void
+  cleanup: (id: string) => void
+}) {
+  const windows = new Map<string, W>()
+  let quitting = false
+  let lastFocusedID: string | undefined
+
+  const persisted = () => {
+    const value = persistence.read()
+    if (!Array.isArray(value)) return []
+    return value.filter((id): id is string => typeof id === "string" && id.length > 0)
+  }
+
+  return {
+    persisted,
+    setQuitting(value = true) {
+      quitting = value
+    },
+    register(id: string, window: W) {
+      windows.set(id, window)
+      const ids = persisted()
+      if (!ids.includes(id)) persistence.write([...ids, id])
+    },
+    focused(id: string) {
+      lastFocusedID = id
+    },
+    lastFocused() {
+      if (!lastFocusedID) return
+      return windows.get(lastFocusedID)
+    },
+    closed(id: string) {
+      windows.delete(id)
+      if (lastFocusedID === id) lastFocusedID = windows.keys().next().value
+      // Only a deliberate close (app keeps running with other windows open)
+      // forgets a window. Closing the last window quits the app and fires
+      // `closed` before `before-quit`, so treat it as a quit and keep the id
+      // for restore on next launch.
+      if (quitting || windows.size === 0) return
+      persistence.write(persisted().filter((item) => item !== id))
+      persistence.cleanup(id)
+    },
+  }
+}