@cuongtran001/kanna 1.3.0 → 1.4.0

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

@@ -0,0 +1,256 @@
+/**
+ * ws-router-project.ts
+ *
+ * WS command handlers for project management, session import, sidebar ordering,
+ * system utilities, and update management:
+ *   system.ping, system.openExternal,
+ *   update.check, update.install, update.reload,
+ *   project.open, project.create, project.remove, project.setStar,
+ *   project.readDiffPatch,
+ *   sessions.importClaude,
+ *   sidebar.reorderProjectGroups
+ *
+ * Extracted from ws-router.ts.
+ */
+import { PROTOCOL_VERSION } from "../shared/types"
+import type { UpdateInstallResult, UpdateSnapshot } from "../shared/types"
+import type { ClientCommand, ServerEnvelope } from "../shared/protocol"
+import type { ImportClaudeSessionsResult } from "./claude-session-importer.adapter"
+
+// ---------------------------------------------------------------------------
+// Dep interfaces (duck-typed; avoids circular imports with ws-router.ts)
+// ---------------------------------------------------------------------------
+
+/** The subset of EventStore consumed by project WS commands. */
+export interface ProjectStoreDep {
+  getProject(projectId: string): { id: string; localPath: string } | null | undefined
+  openProject(localPath: string, title?: string): Promise<{ id: string }>
+  removeProject(projectId: string): Promise<void>
+  setProjectStar(projectId: string, starred: boolean): Promise<void>
+  setSidebarProjectOrder(projectIds: string[]): Promise<void>
+  state: { projectIdsByPath: ReadonlyMap<string, string> }
+}
+
+/** The subset of UpdateManager consumed by update WS commands. */
+export interface ProjectUpdateManagerDep {
+  checkForUpdates(opts?: { force?: boolean }): Promise<UpdateSnapshot>
+  installUpdate(opts?: { version?: string }): Promise<UpdateInstallResult>
+  forceReload(): Promise<UpdateInstallResult>
+}
+
+/** The subset of DiffStore consumed by project.readDiffPatch. */
+export interface ProjectDiffStoreDep {
+  readPatch(args: { projectPath: string; path: string }): Promise<unknown>
+}
+
+/** Analytics reporter subset. */
+export interface ProjectAnalyticsDep {
+  track(event: string): void
+}
+
+/** Terminal manager subset needed to clean up on project removal. */
+export interface ProjectTerminalsDep {
+  closeByCwd(cwd: string): void
+}
+
+export interface ProjectCommandDeps {
+  /** Project-related store methods. */
+  store: ProjectStoreDep
+  /** Update manager — optional; commands fail gracefully when absent. */
+  updateManager?: ProjectUpdateManagerDep | null
+  /** Diff store for readPatch. */
+  diffStore: ProjectDiffStoreDep
+  /** Analytics reporter. */
+  analytics: ProjectAnalyticsDep
+  /** Re-scans the workspace for new/removed projects. */
+  refreshDiscovery: () => Promise<unknown>
+  /** Ensures the target directory exists (creates it if needed). */
+  ensureProjectDirectory: (path: string) => Promise<void>
+  /** Normalizes / resolves a local path string. */
+  resolveLocalPath: (path: string) => string
+  /**
+   * Imports Claude sessions from disk.
+   * Caller pre-binds the store so the function signature is simple.
+   */
+  importClaudeSessionsFn: () => Promise<ImportClaudeSessionsResult>
+  /**
+   * Opens an external application (editor, Finder, browser …).
+   * Caller pre-binds any internal deps.
+   */
+  openExternalFn: (command: Extract<ClientCommand, { type: "system.openExternal" }>) => Promise<void>
+  /** Terminal manager — used to close terminals on project removal. */
+  terminals: ProjectTerminalsDep
+  /** Pre-bound to the current WebSocket; called to send an ack or push envelope. */
+  send: (envelope: ServerEnvelope) => void
+  /**
+   * Broadcast sidebar + project-list snapshots to all connected clients.
+   * Corresponds to `broadcastFilteredSnapshots({ includeSidebar: true })`.
+   */
+  broadcastSidebar: () => Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Command dispatcher
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle one project / session / sidebar / system / update WS command.
+ *
+ * Returns `true` when the command was handled (caller should `return`).
+ * Returns `false` when the command type is outside this module's scope.
+ */
+export async function handleProjectCommand(
+  deps: ProjectCommandDeps,
+  command: ClientCommand,
+  id: string,
+): Promise<boolean> {
+  const {
+    store,
+    updateManager,
+    diffStore,
+    analytics,
+    refreshDiscovery,
+    ensureProjectDirectory,
+    resolveLocalPath,
+    importClaudeSessionsFn,
+    openExternalFn,
+    terminals,
+    send,
+    broadcastSidebar,
+  } = deps
+
+  switch (command.type) {
+    // -----------------------------------------------------------------------
+    // system
+    // -----------------------------------------------------------------------
+    case "system.ping": {
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "system.openExternal": {
+      await openExternalFn(command)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+
+    // -----------------------------------------------------------------------
+    // update
+    // -----------------------------------------------------------------------
+    case "update.check": {
+      const unavailableSnapshot: UpdateSnapshot = {
+        currentVersion: "unknown",
+        latestVersion: null,
+        status: "error",
+        updateAvailable: false,
+        lastCheckedAt: Date.now(),
+        error: "Update manager unavailable.",
+        installAction: "restart",
+        reloadRequestedAt: null,
+      }
+      const snapshot = updateManager
+        ? await updateManager.checkForUpdates({ force: command.force })
+        : unavailableSnapshot
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+      return true
+    }
+    case "update.install": {
+      if (!updateManager) {
+        throw new Error("Update manager unavailable.")
+      }
+      const result = await updateManager.installUpdate({ version: command.version })
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      return true
+    }
+    case "update.reload": {
+      if (!updateManager) {
+        throw new Error("Update manager unavailable.")
+      }
+      const result = await updateManager.forceReload()
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      return true
+    }
+
+    // -----------------------------------------------------------------------
+    // project
+    // -----------------------------------------------------------------------
+    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({ v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id } })
+      if (!existingProjectId) {
+        analytics.track("project_opened")
+      }
+      return true
+    }
+    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({ v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id } })
+      if (!existingProjectId) {
+        analytics.track("project_opened")
+        analytics.track("project_created")
+      }
+      return true
+    }
+    case "project.remove": {
+      const project = store.getProject(command.projectId)
+      await store.removeProject(command.projectId)
+      if (project) {
+        terminals.closeByCwd(project.localPath)
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      analytics.track("project_removed")
+      return true
+    }
+    case "project.setStar": {
+      await store.setProjectStar(command.projectId, command.starred)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastSidebar()
+      return true
+    }
+    case "project.readDiffPatch": {
+      const project = store.getProject(command.projectId)
+      if (!project) {
+        throw new Error("Project not found")
+      }
+      const result = await diffStore.readPatch({
+        projectPath: project.localPath,
+        path: command.path,
+      })
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      return true
+    }
+
+    // -----------------------------------------------------------------------
+    // sessions
+    // -----------------------------------------------------------------------
+    case "sessions.importClaude": {
+      const result = await importClaudeSessionsFn()
+      if (result.newProjects > 0) {
+        await refreshDiscovery()
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      await broadcastSidebar()
+      return true
+    }
+
+    // -----------------------------------------------------------------------
+    // sidebar
+    // -----------------------------------------------------------------------
+    case "sidebar.reorderProjectGroups": {
+      await store.setSidebarProjectOrder(command.projectIds)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastSidebar()
+      return true
+    }
+
+    default:
+      return false
+  }
+}

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

@@ -0,0 +1,193 @@
+import { describe, expect, mock, test } from "bun:test"
+import type { PushCommandDeps, PushManagerDep } from "./ws-router-push"
+import { handlePushCommand } from "./ws-router-push"
+import type { ClientCommand } from "../shared/protocol"
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makePushManager(overrides: Partial<PushManagerDep> = {}): PushManagerDep {
+  return {
+    recordDeviceSeen: mock(async () => {}),
+    addSubscription: mock(async () => ({ id: "sub-1" })),
+    removeSubscription: mock(async () => {}),
+    sendTest: mock(async () => {}),
+    setProjectMute: mock(async () => {}),
+    setFocusedChat: mock(() => {}),
+    ...overrides,
+  }
+}
+
+interface TestDeps extends PushCommandDeps {
+  sent: unknown[]
+  broadcasts: Array<{ includePushConfig: boolean }>
+  _deviceId: string | null | undefined
+}
+
+function makeDeps(
+  pushManagerOverrides?: Partial<PushManagerDep>,
+  initialDeviceId?: string | null,
+): TestDeps {
+  const sent: unknown[] = []
+  const broadcasts: Array<{ includePushConfig: boolean }> = []
+  let deviceId: string | null | undefined = initialDeviceId
+
+  return {
+    pushManager: makePushManager(pushManagerOverrides),
+    getPushDeviceId: () => deviceId,
+    setPushDeviceId: (id) => { deviceId = id },
+    send: (envelope) => { sent.push(envelope) },
+    broadcastPushConfig: async () => { broadcasts.push({ includePushConfig: true }) },
+    sent,
+    broadcasts,
+    get _deviceId() { return deviceId },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Unknown command
+// ---------------------------------------------------------------------------
+
+describe("handlePushCommand", () => {
+  test("returns false for a non-push command", async () => {
+    const deps = makeDeps()
+    const handled = await handlePushCommand(
+      deps,
+      { type: "settings.readAppSettings" } as unknown as ClientCommand,
+      "r0",
+    )
+    expect(handled).toBe(false)
+    expect(deps.sent).toHaveLength(0)
+    expect(deps.broadcasts).toHaveLength(0)
+  })
+
+  // ---------------------------------------------------------------------------
+  // push.identifyDevice
+  // ---------------------------------------------------------------------------
+
+  test("push.identifyDevice — sets deviceId, calls recordDeviceSeen, broadcasts, acks", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "push.identifyDevice", pushDeviceId: "dev-1" }
+    const handled = await handlePushCommand(deps, cmd, "r1")
+    expect(handled).toBe(true)
+    expect(deps._deviceId).toBe("dev-1")
+    expect(deps.pushManager.recordDeviceSeen as ReturnType<typeof mock>).toHaveBeenCalledWith("dev-1")
+    expect(deps.broadcasts).toHaveLength(1)
+    expect(deps.broadcasts[0]).toEqual({ includePushConfig: true })
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  test("push.identifyDevice with null — sets null, skips recordDeviceSeen, no broadcast", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "push.identifyDevice", pushDeviceId: null }
+    const handled = await handlePushCommand(deps, cmd, "r2")
+    expect(handled).toBe(true)
+    expect(deps._deviceId).toBeNull()
+    expect(deps.pushManager.recordDeviceSeen as ReturnType<typeof mock>).not.toHaveBeenCalled()
+    expect(deps.broadcasts).toHaveLength(0)
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  // ---------------------------------------------------------------------------
+  // push.subscribe
+  // ---------------------------------------------------------------------------
+
+  test("push.subscribe — calls addSubscription, sets deviceId from result, broadcasts, acks with result", async () => {
+    const deps = makeDeps({ addSubscription: mock(async () => ({ id: "sub-new" })) })
+    const cmd: ClientCommand = {
+      type: "push.subscribe",
+      subscription: { endpoint: "https://example.com/push", keys: { p256dh: "abc", auth: "def" } },
+      label: "Test device",
+      userAgent: "Bun/1.0",
+    }
+    const handled = await handlePushCommand(deps, cmd, "r3")
+    expect(handled).toBe(true)
+    expect(deps._deviceId).toBe("sub-new")
+    expect(deps.broadcasts).toHaveLength(1)
+    const ack = deps.sent[0] as { type: string; result: unknown }
+    expect(ack.type).toBe("ack")
+    expect(ack.result).toEqual({ id: "sub-new" })
+  })
+
+  // ---------------------------------------------------------------------------
+  // push.unsubscribe
+  // ---------------------------------------------------------------------------
+
+  test("push.unsubscribe — calls removeSubscription, clears deviceId when it matches, broadcasts, acks", async () => {
+    const deps = makeDeps(undefined, "dev-1")
+    const cmd: ClientCommand = { type: "push.unsubscribe", pushDeviceId: "dev-1" }
+    const handled = await handlePushCommand(deps, cmd, "r4")
+    expect(handled).toBe(true)
+    expect(deps.pushManager.removeSubscription as ReturnType<typeof mock>).toHaveBeenCalledWith("dev-1", "user_revoked")
+    expect(deps._deviceId).toBeNull()
+    expect(deps.broadcasts).toHaveLength(1)
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  test("push.unsubscribe — does not clear deviceId when different device is unsubscribed", async () => {
+    const deps = makeDeps(undefined, "dev-1")
+    const cmd: ClientCommand = { type: "push.unsubscribe", pushDeviceId: "dev-2" }
+    await handlePushCommand(deps, cmd, "r5")
+    expect(deps._deviceId).toBe("dev-1")
+  })
+
+  // ---------------------------------------------------------------------------
+  // push.test
+  // ---------------------------------------------------------------------------
+
+  test("push.test — calls sendTest with current deviceId and acks", async () => {
+    const deps = makeDeps(undefined, "dev-1")
+    const cmd: ClientCommand = { type: "push.test" }
+    const handled = await handlePushCommand(deps, cmd, "r6")
+    expect(handled).toBe(true)
+    expect(deps.pushManager.sendTest as ReturnType<typeof mock>).toHaveBeenCalledWith("dev-1")
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  test("push.test — skips sendTest when no deviceId, still acks", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "push.test" }
+    const handled = await handlePushCommand(deps, cmd, "r7")
+    expect(handled).toBe(true)
+    expect(deps.pushManager.sendTest as ReturnType<typeof mock>).not.toHaveBeenCalled()
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  // ---------------------------------------------------------------------------
+  // push.setProjectMute
+  // ---------------------------------------------------------------------------
+
+  test("push.setProjectMute — calls setProjectMute, broadcasts, acks", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "push.setProjectMute", localPath: "/projects/foo", muted: true }
+    const handled = await handlePushCommand(deps, cmd, "r8")
+    expect(handled).toBe(true)
+    expect(deps.pushManager.setProjectMute as ReturnType<typeof mock>).toHaveBeenCalledWith("/projects/foo", true)
+    expect(deps.broadcasts).toHaveLength(1)
+    expect(deps.broadcasts[0]).toEqual({ includePushConfig: true })
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  // ---------------------------------------------------------------------------
+  // push.setFocusedChat
+  // ---------------------------------------------------------------------------
+
+  test("push.setFocusedChat — calls setFocusedChat when deviceId is set, acks", async () => {
+    const deps = makeDeps(undefined, "dev-1")
+    const cmd: ClientCommand = { type: "push.setFocusedChat", chatId: "chat-42" }
+    const handled = await handlePushCommand(deps, cmd, "r9")
+    expect(handled).toBe(true)
+    expect(deps.pushManager.setFocusedChat as ReturnType<typeof mock>).toHaveBeenCalledWith("dev-1", "chat-42")
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+
+  test("push.setFocusedChat — skips setFocusedChat when no deviceId, still acks", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "push.setFocusedChat", chatId: "chat-42" }
+    const handled = await handlePushCommand(deps, cmd, "r10")
+    expect(handled).toBe(true)
+    expect(deps.pushManager.setFocusedChat as ReturnType<typeof mock>).not.toHaveBeenCalled()
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+  })
+})

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

@@ -0,0 +1,120 @@
+/**
+ * ws-router-push.ts
+ *
+ * WS command handlers for push-notification lifecycle operations:
+ *   push.identifyDevice, push.subscribe, push.unsubscribe,
+ *   push.test, push.setProjectMute, push.setFocusedChat
+ *
+ * Extracted from ws-router.ts.
+ */
+import { PROTOCOL_VERSION } from "../shared/types"
+import type { PushSubscribeRequestPayload } from "../shared/types"
+import type { ClientCommand, ServerEnvelope } from "../shared/protocol"
+
+// ---------------------------------------------------------------------------
+// Dep interfaces (duck-typed; avoids circular imports with ws-router.ts)
+// ---------------------------------------------------------------------------
+
+/** The subset of PushManager methods consumed by push WS commands. */
+export interface PushManagerDep {
+  recordDeviceSeen(id: string): Promise<void>
+  addSubscription(args: {
+    subscription: PushSubscribeRequestPayload
+    label: string
+    userAgent: string
+  }): Promise<{ id: string }>
+  removeSubscription(id: string, reason: "user_revoked" | "expired" | "replaced"): Promise<void>
+  sendTest(id: string): Promise<void>
+  setProjectMute(localPath: string, muted: boolean): Promise<void>
+  setFocusedChat(deviceId: string, chatId: string | null): void
+}
+
+export interface PushCommandDeps {
+  /** Push manager for device/subscription operations. */
+  pushManager: PushManagerDep
+  /** Read the current connection's push device id. */
+  getPushDeviceId: () => string | null | undefined
+  /** Persist a new device id on the current connection (or null to clear). */
+  setPushDeviceId: (id: string | null) => void
+  /** Pre-bound to the current WebSocket; called to send an ack envelope. */
+  send: (envelope: ServerEnvelope) => void
+  /**
+   * Broadcast the updated push-config snapshot to all connected clients.
+   * Called after any operation that changes subscription or mute state.
+   */
+  broadcastPushConfig: () => Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Command dispatcher
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle one push WS command.
+ *
+ * Returns `true` when the command was handled (caller should `return`).
+ * Returns `false` when the command type is outside this module's scope.
+ */
+export async function handlePushCommand(
+  deps: PushCommandDeps,
+  command: ClientCommand,
+  id: string,
+): Promise<boolean> {
+  const { pushManager, getPushDeviceId, setPushDeviceId, send, broadcastPushConfig } = deps
+
+  switch (command.type) {
+    case "push.identifyDevice": {
+      setPushDeviceId(command.pushDeviceId)
+      if (command.pushDeviceId) {
+        await pushManager.recordDeviceSeen(command.pushDeviceId)
+        await broadcastPushConfig()
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "push.subscribe": {
+      const result = await pushManager.addSubscription({
+        subscription: command.subscription,
+        label: command.label,
+        userAgent: command.userAgent,
+      })
+      setPushDeviceId(result.id)
+      await broadcastPushConfig()
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      return true
+    }
+    case "push.unsubscribe": {
+      await pushManager.removeSubscription(command.pushDeviceId, "user_revoked")
+      if (getPushDeviceId() === command.pushDeviceId) {
+        setPushDeviceId(null)
+      }
+      await broadcastPushConfig()
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "push.test": {
+      const deviceId = getPushDeviceId()
+      if (deviceId) {
+        await pushManager.sendTest(deviceId)
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "push.setProjectMute": {
+      await pushManager.setProjectMute(command.localPath, command.muted)
+      await broadcastPushConfig()
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    case "push.setFocusedChat": {
+      const deviceId = getPushDeviceId()
+      if (deviceId) {
+        pushManager.setFocusedChat(deviceId, command.chatId)
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      return true
+    }
+    default:
+      return false
+  }
+}