@cuongtran001/kanna 0.39.2

package/src/server/read-models.ts

@@ -0,0 +1,230 @@
+import process from "node:process"
+import type {
+  ChatRuntime,
+  ChatSnapshot,
+  KannaStatus,
+  LocalProjectsSnapshot,
+  SidebarChatRow,
+  SidebarData,
+  SidebarProjectGroup,
+} from "../shared/types"
+import type { ChatRecord, StoreState } from "./events"
+import { resolveLocalPath } from "./paths"
+import { SERVER_PROVIDERS } from "./provider-catalog"
+import { deriveChatSchedules } from "./auto-continue/read-model"
+import { deriveChatTunnels } from "./cloudflare-tunnel/read-model"
+import type { CloudflareTunnelEvent } from "./cloudflare-tunnel/events"
+
+const SIDEBAR_RECENT_WINDOW_MS = 24 * 60 * 60 * 1_000
+const SIDEBAR_FALLBACK_PREVIEW_LIMIT = 5
+
+export function deriveStatus(chat: ChatRecord, activeStatus?: KannaStatus): KannaStatus {
+  if (activeStatus) return activeStatus
+  if (chat.lastTurnOutcome === "failed") return "failed"
+  return "idle"
+}
+
+function getSidebarChatSortTimestamp(chat: ChatRecord) {
+  return chat.lastMessageAt ?? chat.createdAt
+}
+
+function canForkChat(
+  chat: ChatRecord,
+  activeStatuses: Map<string, KannaStatus>,
+  drainingChatIds: Set<string>,
+) {
+  if (!chat.provider) return false
+  if (!chat.sessionToken && !chat.pendingForkSessionToken) return false
+  if (activeStatuses.has(chat.id)) return false
+  if (drainingChatIds.has(chat.id)) return false
+  return true
+}
+
+function getSidebarChatTimestamp(chat: Pick<SidebarChatRow, "lastMessageAt" | "_creationTime">) {
+  return chat.lastMessageAt ?? chat._creationTime
+}
+
+function isSidebarChatRecent(chat: Pick<SidebarChatRow, "lastMessageAt" | "_creationTime">, nowMs: number) {
+  return Math.max(0, nowMs - getSidebarChatTimestamp(chat)) < SIDEBAR_RECENT_WINDOW_MS
+}
+
+function getSidebarChatBuckets(chats: SidebarChatRow[], nowMs: number) {
+  const recentChats = chats.filter((chat) => isSidebarChatRecent(chat, nowMs))
+  const previewChats = recentChats.length > 0
+    ? recentChats
+    : chats.slice(0, Math.min(SIDEBAR_FALLBACK_PREVIEW_LIMIT, chats.length))
+  const previewChatIds = new Set(previewChats.map((chat) => chat.chatId))
+
+  return {
+    previewChats,
+    olderChats: chats.filter((chat) => !previewChatIds.has(chat.chatId)),
+  }
+}
+
+export function deriveSidebarData(
+  state: StoreState,
+  activeStatuses: Map<string, KannaStatus>,
+  options?: {
+    nowMs?: number
+    sidebarProjectOrder?: string[]
+    drainingChatIds?: Set<string>
+  }
+): SidebarData {
+  const nowMs = options?.nowMs ?? Date.now()
+  const drainingChatIds = options?.drainingChatIds ?? new Set<string>()
+  const chatsByProjectId = new Map<string, ChatRecord[]>()
+  const archivedChatsByProjectId = new Map<string, ChatRecord[]>()
+  for (const chat of state.chatsById.values()) {
+    if (chat.deletedAt) continue
+    const targetMap = chat.archivedAt ? archivedChatsByProjectId : chatsByProjectId
+    const projectChats = targetMap.get(chat.projectId)
+    if (projectChats) {
+      projectChats.push(chat)
+      continue
+    }
+    targetMap.set(chat.projectId, [chat])
+  }
+
+  const allProjects = [...state.projectsById.values()]
+    .filter((project) => !project.deletedAt)
+  const unorderedProjects = allProjects
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+  const projectById = new Map(unorderedProjects.map((project) => [project.id, project]))
+  const orderedProjects = (options?.sidebarProjectOrder ?? [])
+    .map((projectId) => projectById.get(projectId))
+    .filter((project): project is NonNullable<typeof project> => Boolean(project))
+  const orderedProjectIds = new Set(orderedProjects.map((project) => project.id))
+  const projects = [
+    ...orderedProjects,
+    ...unorderedProjects.filter((project) => !orderedProjectIds.has(project.id)),
+  ]
+
+  function toSidebarChatRows(project: NonNullable<typeof projects[number]>, projectChats: ChatRecord[]) {
+    return projectChats
+      .sort((a, b) => getSidebarChatSortTimestamp(b) - getSidebarChatSortTimestamp(a))
+      .map((chat) => ({
+        _id: chat.id,
+        _creationTime: chat.createdAt,
+        chatId: chat.id,
+        title: chat.title,
+        status: deriveStatus(chat, activeStatuses.get(chat.id)),
+        unread: chat.unread,
+        localPath: project.localPath,
+        provider: chat.provider,
+        lastMessageAt: chat.lastMessageAt,
+        hasAutomation: false,
+        canFork: canForkChat(chat, activeStatuses, drainingChatIds) || undefined,
+      }))
+  }
+
+  const projectGroups: SidebarProjectGroup[] = projects.map((project) => {
+    const chats = toSidebarChatRows(project, chatsByProjectId.get(project.id) ?? [])
+    const archivedChats = toSidebarChatRows(project, archivedChatsByProjectId.get(project.id) ?? [])
+    const { previewChats, olderChats } = getSidebarChatBuckets(chats, nowMs)
+
+    return {
+      groupKey: project.id,
+      localPath: project.localPath,
+      chats,
+      previewChats,
+      olderChats,
+      ...(archivedChats.length ? { archivedChats } : {}),
+      defaultCollapsed: chats.every((chat) => !isSidebarChatRecent(chat, nowMs)),
+    }
+  })
+
+  return { projectGroups }
+}
+
+export function deriveLocalProjectsSnapshot(
+  state: StoreState,
+  discoveredProjects: Array<{ localPath: string; title: string; modifiedAt: number }>,
+  machineName: string
+): LocalProjectsSnapshot {
+  const projects = new Map<string, LocalProjectsSnapshot["projects"][number]>()
+
+  for (const project of discoveredProjects) {
+    const normalizedPath = resolveLocalPath(project.localPath)
+    projects.set(normalizedPath, {
+      localPath: normalizedPath,
+      title: project.title,
+      source: "discovered",
+      lastOpenedAt: project.modifiedAt,
+      chatCount: 0,
+    })
+  }
+
+  for (const project of [...state.projectsById.values()].filter((entry) => !entry.deletedAt)) {
+    const chats = [...state.chatsById.values()].filter((chat) => chat.projectId === project.id && !chat.deletedAt && !chat.archivedAt)
+    const lastOpenedAt = chats.reduce(
+      (latest, chat) => Math.max(latest, getSidebarChatSortTimestamp(chat)),
+      project.updatedAt
+    )
+
+    projects.set(project.localPath, {
+      localPath: project.localPath,
+      title: project.title,
+      source: "saved",
+      lastOpenedAt,
+      chatCount: chats.length,
+    })
+  }
+
+  return {
+    machine: {
+      id: "local",
+      displayName: machineName,
+      platform: process.platform,
+    },
+    projects: [...projects.values()].sort((a, b) => (b.lastOpenedAt ?? 0) - (a.lastOpenedAt ?? 0)),
+  }
+}
+
+export function deriveChatSnapshot(
+  state: StoreState,
+  activeStatuses: Map<string, KannaStatus>,
+  drainingChatIds: Set<string>,
+  slashCommandsLoadingChatIds: Set<string>,
+  chatId: string,
+  getMessages: (chatId: string) => Pick<ChatSnapshot, "messages" | "history">,
+  getTunnelEvents: (chatId: string) => readonly CloudflareTunnelEvent[]
+): ChatSnapshot | null {
+  const chat = state.chatsById.get(chatId)
+  if (!chat || chat.deletedAt) return null
+  const project = state.projectsById.get(chat.projectId)
+  if (!project || project.deletedAt) return null
+
+  const runtime: ChatRuntime = {
+    chatId: chat.id,
+    projectId: project.id,
+    localPath: project.localPath,
+    title: chat.title,
+    status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    isDraining: drainingChatIds.has(chat.id),
+    provider: chat.provider,
+    planMode: chat.planMode,
+    sessionToken: chat.sessionToken,
+  }
+
+  const transcript = getMessages(chat.id)
+  const autoContinueEvents = state.autoContinueEventsByChatId.get(chat.id) ?? []
+  const { schedules, liveScheduleId } = deriveChatSchedules(autoContinueEvents, chat.id)
+  const { tunnels, liveTunnelId } = deriveChatTunnels(getTunnelEvents(chat.id), chat.id)
+
+  return {
+    runtime,
+    queuedMessages: (state.queuedMessagesByChatId.get(chat.id) ?? []).map((entry) => ({
+      ...entry,
+      attachments: [...entry.attachments],
+    })),
+    messages: transcript.messages,
+    history: transcript.history,
+    availableProviders: [...SERVER_PROVIDERS],
+    slashCommands: (chat.slashCommands ?? []).map((c) => ({ ...c })),
+    slashCommandsLoading: slashCommandsLoadingChatIds.has(chat.id),
+    schedules,
+    liveScheduleId,
+    tunnels,
+    liveTunnelId,
+  }
+}

package/src/server/restart.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test"
+import {
+  CLI_CHILD_ARGS_ENV_VAR,
+  CLI_STARTUP_UPDATE_RESTART_EXIT_CODE,
+  CLI_UI_UPDATE_RESTART_EXIT_CODE,
+  isUiUpdateRestart,
+  parseChildArgsEnv,
+  shouldRestartCliProcess,
+} from "./restart"
+
+describe("shouldRestartCliProcess", () => {
+  test("restarts only for the sentinel exit code without a signal", () => {
+    expect(shouldRestartCliProcess(CLI_STARTUP_UPDATE_RESTART_EXIT_CODE, null)).toBe(true)
+    expect(shouldRestartCliProcess(CLI_UI_UPDATE_RESTART_EXIT_CODE, null)).toBe(true)
+    expect(shouldRestartCliProcess(0, null)).toBe(false)
+    expect(shouldRestartCliProcess(1, null)).toBe(false)
+    expect(shouldRestartCliProcess(CLI_STARTUP_UPDATE_RESTART_EXIT_CODE, "SIGTERM")).toBe(false)
+    expect(isUiUpdateRestart(CLI_UI_UPDATE_RESTART_EXIT_CODE, null)).toBe(true)
+    expect(isUiUpdateRestart(CLI_STARTUP_UPDATE_RESTART_EXIT_CODE, null)).toBe(false)
+  })
+
+  test("parses configured child args from the environment", () => {
+    expect(parseChildArgsEnv(undefined)).toEqual([])
+    expect(parseChildArgsEnv("[\"run\",\"./scripts/dev-server.ts\"]")).toEqual(["run", "./scripts/dev-server.ts"])
+    expect(() => parseChildArgsEnv("{\"bad\":true}")).toThrow(`Invalid ${CLI_CHILD_ARGS_ENV_VAR}`)
+  })
+})

package/src/server/restart.ts

@@ -0,0 +1,30 @@
+export const CLI_CHILD_MODE_ENV_VAR = "KANNA_CLI_MODE"
+export const CLI_CHILD_MODE = "child"
+export const CLI_STARTUP_UPDATE_RESTART_EXIT_CODE = 75
+export const CLI_UI_UPDATE_RESTART_EXIT_CODE = 76
+export const CLI_CHILD_COMMAND_ENV_VAR = "KANNA_CLI_CHILD_COMMAND"
+export const CLI_CHILD_ARGS_ENV_VAR = "KANNA_CLI_CHILD_ARGS"
+export const CLI_SUPPRESS_OPEN_ONCE_ENV_VAR = "KANNA_SUPPRESS_OPEN_ONCE"
+
+export function shouldRestartCliProcess(code: number | null, signal: NodeJS.Signals | null) {
+  return signal === null && (code === CLI_STARTUP_UPDATE_RESTART_EXIT_CODE || code === CLI_UI_UPDATE_RESTART_EXIT_CODE)
+}
+
+export function isUiUpdateRestart(code: number | null, signal: NodeJS.Signals | null) {
+  return signal === null && code === CLI_UI_UPDATE_RESTART_EXIT_CODE
+}
+
+export function parseChildArgsEnv(value: string | undefined) {
+  if (!value) return []
+
+  try {
+    const parsed = JSON.parse(value) as unknown
+    if (!Array.isArray(parsed) || !parsed.every((entry) => typeof entry === "string")) {
+      throw new Error("child args must be an array of strings")
+    }
+    return parsed
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`Invalid ${CLI_CHILD_ARGS_ENV_VAR}: ${message}`)
+  }
+}