kanna-code 0.33.9 → 0.34.1

package/src/server/ws-router.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, test } from "bun:test"
-import type { KeybindingsSnapshot, LlmProviderSnapshot, UpdateSnapshot } from "../shared/types"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import type { AppSettingsSnapshot, KeybindingsSnapshot, LlmProviderSnapshot, UpdateSnapshot } from "../shared/types"
 import { PROTOCOL_VERSION } from "../shared/types"
 import { createEmptyState } from "./events"
 import { createWsRouter } from "./ws-router"
@@ -56,6 +59,12 @@ const DEFAULT_KEYBINDINGS_SNAPSHOT: KeybindingsSnapshot = {
   filePathDisplay: "~/.kanna/keybindings.json",
 }
 
+const DEFAULT_APP_SETTINGS_SNAPSHOT: AppSettingsSnapshot = {
+  analyticsEnabled: true,
+  warning: null,
+  filePathDisplay: "~/.kanna/data/settings.json",
+}
+
 const DEFAULT_UPDATE_SNAPSHOT: UpdateSnapshot = {
   currentVersion: "0.12.0",
   latestVersion: null,
@@ -211,6 +220,258 @@ describe("ws-router", () => {
     }])
   })
 
+  test("reads and writes app settings via commands", async () => {
+    const writes: Array<{ analyticsEnabled: boolean }> = []
+    let analyticsEnabled = DEFAULT_APP_SETTINGS_SNAPSHOT.analyticsEnabled
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      appSettings: {
+        getSnapshot: () => ({
+          ...DEFAULT_APP_SETTINGS_SNAPSHOT,
+          analyticsEnabled,
+        }),
+        write: async (value) => {
+          writes.push(value)
+          analyticsEnabled = value.analyticsEnabled
+          return {
+            ...DEFAULT_APP_SETTINGS_SNAPSHOT,
+            analyticsEnabled: value.analyticsEnabled,
+          }
+        },
+      },
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "settings-read-1",
+        command: { type: "settings.readAppSettings" },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "settings-write-1",
+        command: {
+          type: "settings.writeAppSettings",
+          analyticsEnabled: false,
+        },
+      })
+    )
+
+    expect(ws.sent).toEqual([
+      {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        id: "settings-read-1",
+        result: DEFAULT_APP_SETTINGS_SNAPSHOT,
+      },
+      {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        id: "settings-write-1",
+        result: {
+          ...DEFAULT_APP_SETTINGS_SNAPSHOT,
+          analyticsEnabled: false,
+        },
+      },
+    ])
+    expect(writes).toEqual([{ analyticsEnabled: false }])
+  })
+
+  test("tracks analytics preference transitions in the correct order", async () => {
+    const analyticsEvents: string[] = []
+    let analyticsEnabled = true
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      appSettings: {
+        getSnapshot: () => ({
+          ...DEFAULT_APP_SETTINGS_SNAPSHOT,
+          analyticsEnabled,
+        }),
+        write: async (value) => {
+          analyticsEnabled = value.analyticsEnabled
+          return {
+            ...DEFAULT_APP_SETTINGS_SNAPSHOT,
+            analyticsEnabled: value.analyticsEnabled,
+          }
+        },
+      },
+      analytics: {
+        track: (eventName: string) => {
+          analyticsEvents.push(eventName)
+        },
+        trackLaunch: () => {},
+      },
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "settings-disable-1",
+        command: {
+          type: "settings.writeAppSettings",
+          analyticsEnabled: false,
+        },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "settings-enable-1",
+        command: {
+          type: "settings.writeAppSettings",
+          analyticsEnabled: true,
+        },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "settings-enable-2",
+        command: {
+          type: "settings.writeAppSettings",
+          analyticsEnabled: true,
+        },
+      })
+    )
+
+    expect(analyticsEvents).toEqual([
+      "analytics_disabled",
+      "analytics_enabled",
+    ])
+  })
+
+  test("tracks project lifecycle analytics", async () => {
+    const analyticsEvents: string[] = []
+    const state = createEmptyState()
+    const projectPath = await mkdtemp(path.join(tmpdir(), "kanna-router-project-"))
+
+    try {
+      const router = createWsRouter({
+        store: {
+          state,
+          openProject: async (localPath: string, title?: string) => {
+            const project = {
+              id: "project-1",
+              localPath,
+              title: title ?? "Project",
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              deletedAt: null,
+            }
+            state.projectsById.set(project.id, project as never)
+            state.projectIdsByPath.set(localPath, project.id)
+            return project
+          },
+          getProject: () => ({
+            id: "project-1",
+            localPath: projectPath,
+          }),
+          listChatsByProject: () => [{ id: "chat-1" }, { id: "chat-2" }],
+          removeProject: async () => {},
+        } as never,
+        agent: {
+          cancel: async () => {},
+          closeChat: async () => {},
+          getActiveStatuses: () => new Map(),
+          getDrainingChatIds: () => new Set(),
+        } as never,
+        analytics: {
+          track: (eventName: string) => {
+            analyticsEvents.push(eventName)
+          },
+          trackLaunch: () => {},
+        },
+        terminals: {
+          closeByCwd: () => {},
+          getSnapshot: () => null,
+          onEvent: () => () => {},
+        } as never,
+        keybindings: {
+          getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+          onChange: () => () => {},
+        } as never,
+        refreshDiscovery: async () => [],
+        getDiscoveredProjects: () => [],
+        machineDisplayName: "Local Machine",
+        updateManager: null,
+      })
+      const ws = new FakeWebSocket()
+
+      await router.handleMessage(
+        ws as never,
+        JSON.stringify({
+          v: 1,
+          type: "command",
+          id: "project-create-1",
+          command: { type: "project.create", localPath: projectPath, title: "Project" },
+        })
+      )
+
+      await router.handleMessage(
+        ws as never,
+        JSON.stringify({
+          v: 1,
+          type: "command",
+          id: "project-remove-1",
+          command: { type: "project.remove", projectId: "project-1" },
+        })
+      )
+
+      expect(analyticsEvents).toEqual([
+        "project_opened",
+        "project_created",
+        "project_removed",
+        "chat_deleted",
+        "chat_deleted",
+      ])
+    } finally {
+      await rm(projectPath, { recursive: true, force: true })
+    }
+  })
+
   test("acks terminal.input without rebroadcasting terminal snapshots", async () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,

package/src/server/ws-router.ts

@@ -3,17 +3,19 @@ import { PROTOCOL_VERSION } from "../shared/types"
 import type { ClientEnvelope, ServerEnvelope, SubscriptionTopic } from "../shared/protocol"
 import { isClientEnvelope } from "../shared/protocol"
 import type { AgentCoordinator } from "./agent"
+import type { AnalyticsReporter } from "./analytics"
+import { NoopAnalyticsReporter } from "./analytics"
+import type { AppSettingsManager } from "./app-settings"
 import type { DiscoveredProject } from "./discovery"
 import { DiffStore } from "./diff-store"
 import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
 import { KeybindingsManager } from "./keybindings"
-import { ensureProjectDirectory } from "./paths"
+import { ensureProjectDirectory, resolveLocalPath } from "./paths"
 import { TerminalManager } from "./terminal-manager"
 import type { UpdateManager } from "./update-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
-import type { LlmProviderSnapshot } from "../shared/types"
-import type { LlmProviderValidationResult } from "../shared/types"
+import type { AppSettingsSnapshot, LlmProviderSnapshot, LlmProviderValidationResult } from "../shared/types"
 
 const DEFAULT_CHAT_RECENT_LIMIT = 200
 
@@ -98,6 +100,8 @@ interface CreateWsRouterArgs {
   agent: AgentCoordinator
   terminals: TerminalManager
   keybindings: KeybindingsManager
+  appSettings?: Pick<AppSettingsManager, "getSnapshot" | "write">
+  analytics?: AnalyticsReporter
   llmProvider?: {
     read: () => Promise<LlmProviderSnapshot>
     write: (value: Pick<LlmProviderSnapshot, "provider" | "apiKey" | "model" | "baseUrl">) => Promise<LlmProviderSnapshot>
@@ -152,6 +156,8 @@ export function createWsRouter({
   agent,
   terminals,
   keybindings,
+  appSettings,
+  analytics,
   llmProvider,
   refreshDiscovery,
   getDiscoveredProjects,
@@ -219,6 +225,19 @@ export function createWsRouter({
       },
     }),
   }
+  const resolvedAppSettings = appSettings ?? {
+    getSnapshot: () => ({
+      analyticsEnabled: true,
+      warning: null,
+      filePathDisplay: "~/.kanna/data/settings.json",
+    } satisfies AppSettingsSnapshot),
+    write: async ({ analyticsEnabled }: { analyticsEnabled: boolean }) => ({
+      analyticsEnabled,
+      warning: null,
+      filePathDisplay: "~/.kanna/data/settings.json",
+    } satisfies AppSettingsSnapshot),
+  }
+  const resolvedAnalytics = analytics ?? NoopAnalyticsReporter
 
   function getProtectedChatIds() {
     const activeStatuses = agent.getActiveStatuses()
@@ -734,6 +753,22 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
           return
         }
+        case "settings.readAppSettings": {
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: resolvedAppSettings.getSnapshot() })
+          return
+        }
+        case "settings.writeAppSettings": {
+          const previousAnalyticsEnabled = resolvedAppSettings.getSnapshot().analyticsEnabled
+          if (previousAnalyticsEnabled && !command.analyticsEnabled) {
+            resolvedAnalytics.track("analytics_disabled")
+          }
+          const snapshot = await resolvedAppSettings.write({ analyticsEnabled: command.analyticsEnabled })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+          if (!previousAnalyticsEnabled && command.analyticsEnabled) {
+            resolvedAnalytics.track("analytics_enabled")
+          }
+          return
+        }
         case "settings.readLlmProvider": {
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: await resolvedLlmProvider.read() })
           return
@@ -760,21 +795,33 @@ export function createWsRouter({
         }
         case "project.open": {
           await ensureProjectDirectory(command.localPath)
+          const normalizedPath = resolveLocalPath(command.localPath)
+          const existingProjectId = store.state.projectIdsByPath.get(normalizedPath)
           const project = await store.openProject(command.localPath)
           await refreshDiscovery()
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id } })
+          if (!existingProjectId) {
+            resolvedAnalytics.track("project_opened")
+          }
           break
         }
         case "project.create": {
           await ensureProjectDirectory(command.localPath)
+          const normalizedPath = resolveLocalPath(command.localPath)
+          const existingProjectId = store.state.projectIdsByPath.get(normalizedPath)
           const project = await store.openProject(command.localPath, command.title)
           await refreshDiscovery()
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id } })
+          if (!existingProjectId) {
+            resolvedAnalytics.track("project_opened")
+            resolvedAnalytics.track("project_created")
+          }
           break
         }
         case "project.remove": {
           const project = store.getProject(command.projectId)
-          for (const chat of store.listChatsByProject(command.projectId)) {
+          const chats = store.listChatsByProject(command.projectId)
+          for (const chat of chats) {
             await agent.cancel(chat.id)
             await agent.closeChat(chat.id)
           }
@@ -783,6 +830,10 @@ export function createWsRouter({
           }
           await store.removeProject(command.projectId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          resolvedAnalytics.track("project_removed")
+          for (const _chat of chats) {
+            resolvedAnalytics.track("chat_deleted")
+          }
           break
         }
         case "sidebar.reorderProjectGroups": {
@@ -811,6 +862,7 @@ export function createWsRouter({
         case "chat.create": {
           const chat = await store.createChat(command.projectId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { chatId: chat.id } })
+          resolvedAnalytics.track("chat_created")
           await broadcastChatAndSidebar(chat.id)
           return
         }
@@ -831,6 +883,7 @@ export function createWsRouter({
           await agent.closeChat(command.chatId)
           await store.deleteChat(command.chatId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          resolvedAnalytics.track("chat_deleted")
           await broadcastFilteredSnapshots({ includeSidebar: true })
           return
         }

package/src/shared/analytics.ts

@@ -0,0 +1,30 @@
+export const ANALYTICS_ENDPOINT = "https://kanna.sh/api/t"
+
+export const ANALYTICS_STATIC_EVENT_NAMES = [
+  "app_launch",
+  "project_opened",
+  "project_created",
+  "project_removed",
+  "chat_created",
+  "chat_deleted",
+  "message_sent",
+  "update_checked",
+  "update_installed",
+  "update_failed",
+  "analytics_enabled",
+  "analytics_disabled",
+] as const
+
+export const ANALYTICS_STATIC_PROPERTY_NAMES = [
+  "current_version",
+  "environment",
+  "latest_version",
+  "custom_port_enabled",
+  "no_open_enabled",
+  "password_enabled",
+  "strict_port_enabled",
+  "remote_enabled",
+  "host_enabled",
+  "share_quick_enabled",
+  "share_token_enabled",
+] as const

package/src/shared/branding.ts

@@ -47,6 +47,14 @@ export function getDataDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
   return `${getDataRootDirDisplay(env)}/data`
 }
 
+export function getSettingsFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataDir(homeDir, env)}/settings.json`
+}
+
+export function getSettingsFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataDirDisplay(env)}/settings.json`
+}
+
 export function getKeybindingsFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
   return `${getDataRootDir(homeDir, env)}/keybindings.json`
 }

package/src/shared/protocol.ts

@@ -1,4 +1,5 @@
 import type {
+  AppSettingsSnapshot,
   AgentProvider,
   ChatAttachment,
   ChatDiffSnapshot,
@@ -58,6 +59,8 @@ export type ClientCommand =
   | { type: "update.install" }
   | { type: "settings.readKeybindings" }
   | { type: "settings.writeKeybindings"; bindings: KeybindingsSnapshot["bindings"] }
+  | { type: "settings.readAppSettings" }
+  | { type: "settings.writeAppSettings"; analyticsEnabled: boolean }
   | { type: "settings.readLlmProvider" }
   | {
       type: "settings.writeLlmProvider"
@@ -207,6 +210,7 @@ export type ServerSnapshot =
   | { type: "local-projects"; data: LocalProjectsSnapshot }
   | { type: "update"; data: UpdateSnapshot }
   | { type: "keybindings"; data: KeybindingsSnapshot }
+  | { type: "app-settings"; data: AppSettingsSnapshot }
   | { type: "llm-provider"; data: LlmProviderSnapshot }
   | { type: "chat"; data: ChatSnapshot | null }
   | { type: "project-git"; data: ChatDiffSnapshot | null }

package/src/shared/types.ts

@@ -308,6 +308,12 @@ export interface LocalProjectsSnapshot {
   projects: LocalProjectSummary[]
 }
 
+export interface AppSettingsSnapshot {
+  analyticsEnabled: boolean
+  warning: string | null
+  filePathDisplay: string
+}
+
 export interface LlmProviderFile {
   provider?: LlmProviderKind
   apiKey?: string