kaizenai 0.1.0

package/src/server/theme-settings.ts

@@ -0,0 +1,179 @@
+import { watch, type FSWatcher } from "node:fs"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+import { getThemeSettingsFilePath, LOG_PREFIX } from "../shared/branding"
+import {
+  DEFAULT_THEME_SETTINGS,
+  type ColorTheme,
+  type CustomAppearance,
+  type ThemePreference,
+  type ThemeSettingsSnapshot,
+} from "../shared/types"
+
+const VALID_THEME_PREFERENCES: ThemePreference[] = ["light", "dark", "system", "custom"]
+const VALID_COLOR_THEMES: ColorTheme[] = ["default", "tokyo-night", "catppuccin", "dracula", "nord", "everforest", "rose-pine"]
+const VALID_CUSTOM_APPEARANCES: CustomAppearance[] = ["light", "dark", "system"]
+
+export class ThemeSettingsManager {
+  readonly filePath: string
+  private watcher: FSWatcher | null = null
+  private snapshot: ThemeSettingsSnapshot
+  private readonly listeners = new Set<(snapshot: ThemeSettingsSnapshot) => void>()
+
+  constructor(filePath = getThemeSettingsFilePath(homedir())) {
+    this.filePath = filePath
+    this.snapshot = createDefaultSnapshot(this.filePath)
+  }
+
+  async initialize() {
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    const file = Bun.file(this.filePath)
+    if (!(await file.exists())) {
+      await writeFile(this.filePath, `${JSON.stringify(DEFAULT_THEME_SETTINGS, null, 2)}\n`, "utf8")
+    }
+    await this.reload()
+    this.startWatching()
+  }
+
+  dispose() {
+    this.watcher?.close()
+    this.watcher = null
+    this.listeners.clear()
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: ThemeSettingsSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async reload() {
+    const nextSnapshot = await readThemeSettingsSnapshot(this.filePath)
+    this.setSnapshot(nextSnapshot)
+  }
+
+  async write(settings: ThemeSettingsSnapshot["settings"]) {
+    const nextSnapshot = normalizeThemeSettings(settings, this.filePath)
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    await writeFile(this.filePath, `${JSON.stringify(nextSnapshot.settings, null, 2)}\n`, "utf8")
+    this.setSnapshot(nextSnapshot)
+    return nextSnapshot
+  }
+
+  private setSnapshot(snapshot: ThemeSettingsSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) {
+      listener(snapshot)
+    }
+  }
+
+  private startWatching() {
+    this.watcher?.close()
+    try {
+      this.watcher = watch(path.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path.basename(this.filePath)) {
+          return
+        }
+        void this.reload().catch((error: unknown) => {
+          console.warn(`${LOG_PREFIX} Failed to reload theme settings:`, error)
+        })
+      })
+    } catch (error) {
+      console.warn(`${LOG_PREFIX} Failed to watch theme settings file:`, error)
+      this.watcher = null
+    }
+  }
+}
+
+export async function readThemeSettingsSnapshot(filePath: string): Promise<ThemeSettingsSnapshot> {
+  try {
+    const text = await readFile(filePath, "utf8")
+    if (!text.trim()) {
+      return createDefaultSnapshot(filePath, "Theme settings file was empty. Using defaults.")
+    }
+    const parsed = JSON.parse(text) as Partial<ThemeSettingsSnapshot["settings"]>
+    return normalizeThemeSettings(parsed, filePath)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+      return createDefaultSnapshot(filePath)
+    }
+    if (error instanceof SyntaxError) {
+      return createDefaultSnapshot(filePath, "Theme settings file is invalid JSON. Using defaults.")
+    }
+    throw error
+  }
+}
+
+export function normalizeThemeSettings(
+  value: Partial<ThemeSettingsSnapshot["settings"]> | null | undefined,
+  filePath = getThemeSettingsFilePath(homedir())
+): ThemeSettingsSnapshot {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {}
+
+  const themePreference: ThemePreference = VALID_THEME_PREFERENCES.includes(source.themePreference as ThemePreference)
+    ? source.themePreference as ThemePreference
+    : DEFAULT_THEME_SETTINGS.themePreference
+
+  const colorTheme: ColorTheme = VALID_COLOR_THEMES.includes(source.colorTheme as ColorTheme)
+    ? source.colorTheme as ColorTheme
+    : DEFAULT_THEME_SETTINGS.colorTheme
+
+  const customAppearance: CustomAppearance = VALID_CUSTOM_APPEARANCES.includes(source.customAppearance as CustomAppearance)
+    ? source.customAppearance as CustomAppearance
+    : DEFAULT_THEME_SETTINGS.customAppearance
+
+  const backgroundImage: string | null =
+    typeof source.backgroundImage === "string" ? source.backgroundImage : DEFAULT_THEME_SETTINGS.backgroundImage
+
+  const backgroundOpacity: number =
+    typeof source.backgroundOpacity === "number" && source.backgroundOpacity >= 0 && source.backgroundOpacity <= 1
+      ? source.backgroundOpacity
+      : DEFAULT_THEME_SETTINGS.backgroundOpacity
+
+  const backgroundBlur: number =
+    typeof source.backgroundBlur === "number" && source.backgroundBlur >= 0
+      ? source.backgroundBlur
+      : DEFAULT_THEME_SETTINGS.backgroundBlur
+
+  const showProjectIconsInSidebar: boolean =
+    typeof source.showProjectIconsInSidebar === "boolean"
+      ? source.showProjectIconsInSidebar
+      : DEFAULT_THEME_SETTINGS.showProjectIconsInSidebar
+
+  return {
+    settings: {
+      themePreference,
+      colorTheme,
+      customAppearance,
+      backgroundImage,
+      backgroundOpacity,
+      backgroundBlur,
+      showProjectIconsInSidebar,
+    },
+    warning: null,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function createDefaultSnapshot(filePath: string, warning: string | null = null): ThemeSettingsSnapshot {
+  return {
+    settings: { ...DEFAULT_THEME_SETTINGS },
+    warning,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function formatDisplayPath(filePath: string) {
+  const homePath = homedir()
+  if (filePath === homePath) return "~"
+  if (filePath.startsWith(`${homePath}${path.sep}`)) {
+    return `~${filePath.slice(homePath.length)}`
+  }
+  return filePath
+}

package/src/server/update-manager.ts

@@ -0,0 +1,230 @@
+import type { UpdateInstallResult, UpdateSnapshot } from "../shared/types"
+import { PACKAGE_NAME } from "../shared/branding"
+import { compareVersions, type UpdateInstallAttemptResult } from "./cli-runtime"
+
+const UPDATE_CACHE_TTL_MS = 5 * 60 * 1000
+
+export interface UpdateManagerDeps {
+  currentVersion: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  devMode?: boolean
+}
+
+export class UpdateManager {
+  private readonly deps: UpdateManagerDeps
+  private readonly listeners = new Set<(snapshot: UpdateSnapshot) => void>()
+  private snapshot: UpdateSnapshot
+  private checkPromise: Promise<UpdateSnapshot> | null = null
+  private installPromise: Promise<UpdateInstallResult> | null = null
+
+  constructor(deps: UpdateManagerDeps) {
+    this.deps = deps
+    this.snapshot = {
+      currentVersion: deps.currentVersion,
+      latestVersion: deps.devMode ? `${deps.currentVersion}-dev` : null,
+      status: deps.devMode ? "available" : "idle",
+      updateAvailable: Boolean(deps.devMode),
+      lastCheckedAt: deps.devMode ? Date.now() : null,
+      error: null,
+      installAction: "restart",
+    }
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: UpdateSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async checkForUpdates(options: { force?: boolean } = {}) {
+    if (this.deps.devMode) {
+      return this.snapshot
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return this.snapshot
+    }
+
+    if (this.checkPromise) {
+      return this.checkPromise
+    }
+
+    if (!options.force && this.snapshot.lastCheckedAt && Date.now() - this.snapshot.lastCheckedAt < UPDATE_CACHE_TTL_MS) {
+      return this.snapshot
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "checking",
+      error: null,
+    })
+
+    const checkPromise = this.runCheck()
+    this.checkPromise = checkPromise
+
+    try {
+      return await checkPromise
+    } finally {
+      if (this.checkPromise === checkPromise) {
+        this.checkPromise = null
+      }
+    }
+  }
+
+  async installUpdate(): Promise<UpdateInstallResult> {
+    if (this.deps.devMode) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "updating",
+        error: null,
+      })
+
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "restart_pending",
+        updateAvailable: false,
+        error: null,
+      })
+
+      return {
+        ok: true,
+        action: "restart",
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }
+    }
+
+    if (this.snapshot.status === "updating" || this.snapshot.status === "restart_pending") {
+      return {
+        ok: this.snapshot.updateAvailable,
+        action: "restart",
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }
+    }
+
+    if (this.installPromise) {
+      return this.installPromise
+    }
+
+    const installPromise = this.runInstall()
+    this.installPromise = installPromise
+
+    try {
+      return await installPromise
+    } finally {
+      if (this.installPromise === installPromise) {
+        this.installPromise = null
+      }
+    }
+  }
+
+  private async runCheck() {
+    try {
+      const latestVersion = await this.deps.fetchLatestVersion(PACKAGE_NAME)
+      const updateAvailable = compareVersions(this.snapshot.currentVersion, latestVersion) < 0
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        latestVersion,
+        updateAvailable,
+        status: updateAvailable ? "available" : "up_to_date",
+        lastCheckedAt: Date.now(),
+        error: null,
+      }
+      this.setSnapshot(nextSnapshot)
+      return nextSnapshot
+    } catch (error) {
+      const nextSnapshot: UpdateSnapshot = {
+        ...this.snapshot,
+        status: "error",
+        lastCheckedAt: Date.now(),
+        error: error instanceof Error ? error.message : String(error),
+      }
+      this.setSnapshot(nextSnapshot)
+      return nextSnapshot
+    }
+  }
+
+  private async runInstall(): Promise<UpdateInstallResult> {
+    if (!this.snapshot.updateAvailable) {
+      const snapshot = await this.checkForUpdates({ force: true })
+      if (!snapshot.updateAvailable) {
+        return {
+          ok: false,
+          action: "restart",
+          errorCode: null,
+          userTitle: null,
+          userMessage: null,
+        }
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      status: "updating",
+      error: null,
+    })
+
+    const targetVersion = this.snapshot.latestVersion
+    if (!targetVersion) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "error",
+        error: "Unable to determine which version to install.",
+      })
+      return {
+        ok: false,
+        action: "restart",
+        errorCode: "install_failed",
+        userTitle: "Update failed",
+        userMessage: "Kaizen could not determine which version to install.",
+      }
+    }
+
+    const installed = this.deps.installVersion(PACKAGE_NAME, targetVersion)
+    if (!installed.ok) {
+      this.setSnapshot({
+        ...this.snapshot,
+        status: "error",
+        error: installed.userMessage ?? "Unable to install the latest version.",
+      })
+      return {
+        ok: false,
+        action: "restart",
+        errorCode: installed.errorCode,
+        userTitle: installed.userTitle,
+        userMessage: installed.userMessage,
+      }
+    }
+
+    this.setSnapshot({
+      ...this.snapshot,
+      currentVersion: this.snapshot.latestVersion ?? this.snapshot.currentVersion,
+      status: "restart_pending",
+      updateAvailable: false,
+      error: null,
+    })
+    return {
+      ok: true,
+      action: "restart",
+      errorCode: null,
+      userTitle: null,
+      userMessage: null,
+    }
+  }
+
+  private setSnapshot(snapshot: UpdateSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) {
+      listener(snapshot)
+    }
+  }
+}

package/src/server/usage/base-provider-usage.ts

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import type { AgentProvider, ProviderUsageEntry } from "../../shared/types"
+import { PROVIDERS } from "../../shared/types"
+
+function providerUsageRequestTimesPath(dataDir: string) {
+  return path.join(dataDir, "provider-usage-request-times.json")
+}
+
+function loadProviderUsageRequestTimes(dataDir: string): Partial<Record<AgentProvider, number>> {
+  try {
+    const filePath = providerUsageRequestTimesPath(dataDir)
+    if (!existsSync(filePath)) return {}
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"))
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {}
+    const result: Partial<Record<AgentProvider, number>> = {}
+    for (const provider of PROVIDERS.map((entry) => entry.id)) {
+      const value = (parsed as Record<string, unknown>)[provider]
+      if (typeof value === "number" && Number.isFinite(value)) {
+        result[provider] = value
+      }
+    }
+    return result
+  } catch {
+    return {}
+  }
+}
+
+export abstract class BaseProviderUsage {
+  protected readonly dataDir: string
+
+  constructor(dataDir: string) {
+    this.dataDir = dataDir
+  }
+
+  protected recordRequestTime(provider: AgentProvider, at = Date.now()): void {
+    try {
+      const next = loadProviderUsageRequestTimes(this.dataDir)
+      next[provider] = at
+      writeFileSync(providerUsageRequestTimesPath(this.dataDir), JSON.stringify(next))
+    } catch {
+      // best-effort
+    }
+  }
+
+  protected readLastRequestedAt(provider: AgentProvider): number {
+    return loadProviderUsageRequestTimes(this.dataDir)[provider] ?? 0
+  }
+
+  protected shouldSkipRefresh(provider: AgentProvider, minInterval: number, force = false): boolean {
+    if (force) return false
+    return Date.now() - this.readLastRequestedAt(provider) < minInterval
+  }
+
+  abstract readonly provider: AgentProvider
+  abstract loadPersistedEntry(): ProviderUsageEntry | null
+}