kanna-code 0.33.9 → 0.34.0

package/src/server/app-settings.ts

@@ -0,0 +1,263 @@
+import { randomUUID } from "node:crypto"
+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 { getSettingsFilePath, LOG_PREFIX } from "../shared/branding"
+import type { AppSettingsSnapshot } from "../shared/types"
+
+interface AppSettingsFile {
+  analyticsEnabled?: unknown
+  analyticsUserId?: unknown
+}
+
+interface AppSettingsState extends AppSettingsSnapshot {
+  analyticsUserId: string
+}
+
+interface NormalizedAppSettings {
+  payload: {
+    analyticsEnabled: boolean
+    analyticsUserId: string
+  }
+  warning: string | null
+  shouldWrite: boolean
+}
+
+function formatDisplayPath(filePath: string) {
+  const homePath = homedir()
+  if (filePath === homePath) return "~"
+  if (filePath.startsWith(`${homePath}${path.sep}`)) {
+    return `~${filePath.slice(homePath.length)}`
+  }
+  return filePath
+}
+
+function createAnalyticsUserId() {
+  return `anon_${randomUUID()}`
+}
+
+function normalizeAppSettings(
+  value: unknown,
+  filePath = getSettingsFilePath(homedir())
+): NormalizedAppSettings {
+  const source = value && typeof value === "object" && !Array.isArray(value)
+    ? value as AppSettingsFile
+    : null
+  const warnings: string[] = []
+
+  if (value !== undefined && value !== null && !source) {
+    warnings.push("Settings file must contain a JSON object")
+  }
+
+  const analyticsEnabled = typeof source?.analyticsEnabled === "boolean"
+    ? source.analyticsEnabled
+    : true
+  if (source?.analyticsEnabled !== undefined && typeof source.analyticsEnabled !== "boolean") {
+    warnings.push("analyticsEnabled must be a boolean")
+  }
+
+  const rawAnalyticsUserId = typeof source?.analyticsUserId === "string"
+    ? source.analyticsUserId.trim()
+    : ""
+  if (source?.analyticsUserId !== undefined && typeof source.analyticsUserId !== "string") {
+    warnings.push("analyticsUserId must be a string")
+  }
+
+  const analyticsUserId = rawAnalyticsUserId || createAnalyticsUserId()
+  if (!rawAnalyticsUserId && source?.analyticsUserId !== undefined) {
+    warnings.push("analyticsUserId must be a non-empty string")
+  }
+
+  const shouldWrite = !source
+    || source.analyticsEnabled !== analyticsEnabled
+    || rawAnalyticsUserId !== analyticsUserId
+
+  return {
+    payload: {
+      analyticsEnabled,
+      analyticsUserId,
+    },
+    warning: warnings.length > 0
+      ? `Some settings were reset to defaults: ${warnings.join("; ")}`
+      : null,
+    shouldWrite,
+  }
+}
+
+function toSnapshot(state: AppSettingsState): AppSettingsSnapshot {
+  return {
+    analyticsEnabled: state.analyticsEnabled,
+    warning: state.warning,
+    filePathDisplay: state.filePathDisplay,
+  }
+}
+
+export async function readAppSettingsSnapshot(filePath = getSettingsFilePath(homedir())) {
+  try {
+    const text = await readFile(filePath, "utf8")
+    if (!text.trim()) {
+      const normalized = normalizeAppSettings(undefined, filePath)
+      return {
+        analyticsEnabled: normalized.payload.analyticsEnabled,
+        warning: "Settings file was empty. Using defaults.",
+        filePathDisplay: formatDisplayPath(filePath),
+      } satisfies AppSettingsSnapshot
+    }
+
+    const normalized = normalizeAppSettings(JSON.parse(text), filePath)
+    return {
+      analyticsEnabled: normalized.payload.analyticsEnabled,
+      warning: normalized.warning,
+      filePathDisplay: formatDisplayPath(filePath),
+    } satisfies AppSettingsSnapshot
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+      return {
+        analyticsEnabled: true,
+        warning: null,
+        filePathDisplay: formatDisplayPath(filePath),
+      } satisfies AppSettingsSnapshot
+    }
+    if (error instanceof SyntaxError) {
+      return {
+        analyticsEnabled: true,
+        warning: "Settings file is invalid JSON. Using defaults.",
+        filePathDisplay: formatDisplayPath(filePath),
+      } satisfies AppSettingsSnapshot
+    }
+    throw error
+  }
+}
+
+export class AppSettingsManager {
+  readonly filePath: string
+  private watcher: FSWatcher | null = null
+  private state: AppSettingsState
+  private readonly listeners = new Set<(snapshot: AppSettingsSnapshot) => void>()
+
+  constructor(filePath = getSettingsFilePath(homedir())) {
+    this.filePath = filePath
+    const displayPath = formatDisplayPath(this.filePath)
+    this.state = {
+      analyticsEnabled: true,
+      analyticsUserId: createAnalyticsUserId(),
+      warning: null,
+      filePathDisplay: displayPath,
+    }
+  }
+
+  async initialize() {
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    await this.reload({ persistNormalized: true })
+    this.startWatching()
+  }
+
+  dispose() {
+    this.watcher?.close()
+    this.watcher = null
+    this.listeners.clear()
+  }
+
+  getSnapshot() {
+    return toSnapshot(this.state)
+  }
+
+  getState() {
+    return this.state
+  }
+
+  onChange(listener: (snapshot: AppSettingsSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async reload(options?: { persistNormalized?: boolean }) {
+    const nextState = await this.readState(options)
+    this.setState(nextState)
+  }
+
+  async write(value: { analyticsEnabled: boolean }) {
+    const payload = {
+      analyticsEnabled: value.analyticsEnabled,
+      analyticsUserId: this.state.analyticsUserId || createAnalyticsUserId(),
+    }
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    await writeFile(this.filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8")
+    const nextState: AppSettingsState = {
+      analyticsEnabled: payload.analyticsEnabled,
+      analyticsUserId: payload.analyticsUserId,
+      warning: null,
+      filePathDisplay: formatDisplayPath(this.filePath),
+    }
+    this.setState(nextState)
+    return toSnapshot(nextState)
+  }
+
+  private async readState(options?: { persistNormalized?: boolean }) {
+    const file = Bun.file(this.filePath)
+    const displayPath = formatDisplayPath(this.filePath)
+
+    try {
+      const text = await file.text()
+      const hasText = text.trim().length > 0
+      const normalized = normalizeAppSettings(hasText ? JSON.parse(text) : undefined, this.filePath)
+      if (options?.persistNormalized && (!hasText || normalized.shouldWrite)) {
+        await writeFile(this.filePath, `${JSON.stringify(normalized.payload, null, 2)}\n`, "utf8")
+      }
+      return {
+        analyticsEnabled: normalized.payload.analyticsEnabled,
+        analyticsUserId: normalized.payload.analyticsUserId,
+        warning: !hasText
+          ? "Settings file was empty. Using defaults."
+          : normalized.warning,
+        filePathDisplay: displayPath,
+      } satisfies AppSettingsState
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException)?.code !== "ENOENT" && !(error instanceof SyntaxError)) {
+        throw error
+      }
+
+      const warning = error instanceof SyntaxError
+        ? "Settings file is invalid JSON. Using defaults."
+        : null
+      const normalized = normalizeAppSettings(undefined, this.filePath)
+      if (options?.persistNormalized) {
+        await writeFile(this.filePath, `${JSON.stringify(normalized.payload, null, 2)}\n`, "utf8")
+      }
+      return {
+        analyticsEnabled: normalized.payload.analyticsEnabled,
+        analyticsUserId: normalized.payload.analyticsUserId,
+        warning,
+        filePathDisplay: displayPath,
+      } satisfies AppSettingsState
+    }
+  }
+
+  private setState(state: AppSettingsState) {
+    this.state = state
+    const snapshot = toSnapshot(state)
+    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 settings:`, error)
+        })
+      })
+    } catch (error) {
+      console.warn(`${LOG_PREFIX} Failed to watch settings file:`, error)
+      this.watcher = null
+    }
+  }
+}

package/src/server/server.ts

@@ -2,9 +2,12 @@ import path from "node:path"
 import { stat } from "node:fs/promises"
 import { APP_NAME, getRuntimeProfile } from "../shared/branding"
 import type { ChatAttachment } from "../shared/types"
+import type { ShareMode } from "../shared/share"
 import { createAuthManager } from "./auth"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
+import { KannaAnalyticsReporter } from "./analytics"
+import { AppSettingsManager } from "./app-settings"
 import { DiffStore } from "./diff-store"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
 import { KeybindingsManager } from "./keybindings"
@@ -58,6 +61,8 @@ export async function persistUploadedFiles(args: {
 export interface StartKannaServerOptions {
   port?: number
   host?: string
+  openBrowser?: boolean
+  share?: ShareMode
   dataDir?: string
   password?: string | null
   strictPort?: boolean
@@ -80,6 +85,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const port = options.port ?? 3210
   const hostname = options.host ?? "127.0.0.1"
   const strictPort = options.strictPort ?? false
+  const runtimeProfile = getRuntimeProfile()
   const auth = options.password ? createAuthManager(options.password, { trustProxy: options.trustProxy ?? false }) : null
   const store = new EventStore(options.dataDir)
   const diffStore = new DiffStore(store.dataDir)
@@ -100,17 +106,26 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   let router: ReturnType<typeof createWsRouter>
   const terminals = new TerminalManager()
   const keybindings = new KeybindingsManager()
+  const appSettings = new AppSettingsManager(path.join(store.dataDir, "settings.json"))
+  await appSettings.initialize()
   await keybindings.initialize()
+  const analytics = new KannaAnalyticsReporter({
+    settings: appSettings,
+    currentVersion: options.update?.version ?? "unknown",
+    environment: runtimeProfile === "dev" ? "dev" : "prod",
+  })
   const updateManager = options.update
     ? new UpdateManager({
       currentVersion: options.update.version,
       fetchLatestVersion: options.update.fetchLatestVersion,
       installVersion: options.update.installVersion,
-      devMode: getRuntimeProfile() === "dev",
+      devMode: runtimeProfile === "dev",
+      trackEvent: analytics.track.bind(analytics),
     })
     : null
   const agent = new AgentCoordinator({
     store,
+    analytics,
     onStateChange: (chatId?: string, options?: { immediate?: boolean }) => {
       if (chatId) {
         if (options?.immediate) {
@@ -129,6 +144,8 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     agent,
     terminals,
     keybindings,
+    appSettings,
+    analytics,
     llmProvider: {
       read: readLlmProviderSnapshot,
       write: writeLlmProviderSnapshot,
@@ -256,12 +273,22 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     }
   }
 
+  analytics.trackLaunch({
+    port: actualPort,
+    host: hostname,
+    openBrowser: options.openBrowser ?? true,
+    share: options.share ?? false,
+    password: options.password ?? null,
+    strictPort,
+  })
+
   const shutdown = async () => {
     clearInterval(staleEmptyChatPruneInterval)
     for (const chatId of [...agent.activeTurns.keys()]) {
       await agent.cancel(chatId)
     }
     router.dispose()
+    appSettings.dispose()
     keybindings.dispose()
     terminals.closeAll()
     await store.compact()

package/src/server/update-manager.test.ts

@@ -2,6 +2,41 @@ import { describe, expect, test } from "bun:test"
 import { UpdateManager } from "./update-manager"
 
 describe("UpdateManager", () => {
+  test("tracks update lifecycle events", async () => {
+    const events: Array<{ name: string; properties?: Record<string, unknown> }> = []
+    const manager = new UpdateManager({
+      currentVersion: "0.12.0",
+      fetchLatestVersion: async () => "0.13.0",
+      installVersion: () => ({
+        ok: true,
+        errorCode: null,
+        userTitle: null,
+        userMessage: null,
+      }),
+      trackEvent: (eventName, properties) => {
+        events.push({ name: eventName, properties })
+      },
+    })
+
+    await manager.checkForUpdates({ force: true })
+    await manager.installUpdate()
+
+    expect(events).toEqual([
+      {
+        name: "update_checked",
+        properties: {
+          latest_version: "0.13.0",
+        },
+      },
+      {
+        name: "update_installed",
+        properties: {
+          latest_version: "0.13.0",
+        },
+      },
+    ])
+  })
+
   test("detects available updates", async () => {
     const manager = new UpdateManager({
       currentVersion: "0.12.0",

package/src/server/update-manager.ts

@@ -9,6 +9,7 @@ export interface UpdateManagerDeps {
   fetchLatestVersion: (packageName: string) => Promise<string>
   installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
   devMode?: boolean
+  trackEvent?: (eventName: string, properties?: Record<string, unknown>) => void
 }
 
 export class UpdateManager {
@@ -81,6 +82,9 @@ export class UpdateManager {
 
   async installUpdate(): Promise<UpdateInstallResult> {
     if (this.deps.devMode) {
+      this.deps.trackEvent?.("update_installed", {
+        latest_version: this.snapshot.latestVersion,
+      })
       this.setSnapshot({
         ...this.snapshot,
         status: "updating",
@@ -145,6 +149,9 @@ export class UpdateManager {
         reloadRequestedAt: null,
       }
       this.setSnapshot(nextSnapshot)
+      this.deps.trackEvent?.("update_checked", {
+        latest_version: latestVersion,
+      })
       return nextSnapshot
     } catch (error) {
       const nextSnapshot: UpdateSnapshot = {
@@ -155,6 +162,9 @@ export class UpdateManager {
         reloadRequestedAt: null,
       }
       this.setSnapshot(nextSnapshot)
+      this.deps.trackEvent?.("update_failed", {
+        latest_version: this.snapshot.latestVersion,
+      })
       return nextSnapshot
     }
   }
@@ -188,6 +198,9 @@ export class UpdateManager {
         error: "Unable to determine which version to install.",
         reloadRequestedAt: null,
       })
+      this.deps.trackEvent?.("update_failed", {
+        latest_version: null,
+      })
       return {
         ok: false,
         action: "restart",
@@ -205,6 +218,9 @@ export class UpdateManager {
         error: installed.userMessage ?? "Unable to install the latest version.",
         reloadRequestedAt: null,
       })
+      this.deps.trackEvent?.("update_failed", {
+        latest_version: targetVersion,
+      })
       return {
         ok: false,
         action: "restart",
@@ -222,6 +238,9 @@ export class UpdateManager {
       error: null,
       reloadRequestedAt: Date.now(),
     })
+    this.deps.trackEvent?.("update_installed", {
+      latest_version: targetVersion,
+    })
     return {
       ok: true,
       action: "restart",