kanna-code 0.32.3 → 0.33.0

package/src/server/read-models.test.ts

@@ -26,9 +26,10 @@ describe("read models", () => {
       lastTurnOutcome: null,
     })
 
-    const sidebar = deriveSidebarData(state, new Map(), 1_000_000)
+    const sidebar = deriveSidebarData(state, new Map(), { nowMs: 1_000_000 })
     expect(sidebar.projectGroups[0]?.chats[0]?.provider).toBe("codex")
     expect(sidebar.projectGroups[0]?.chats[0]?.unread).toBe(true)
+    expect(sidebar.projectGroups[0]?.chats[0]?.canFork).toBe(true)
     expect(sidebar.projectGroups[0]?.previewChats.map((chat) => chat.chatId)).toEqual(["chat-1"])
     expect(sidebar.projectGroups[0]?.olderChats).toEqual([])
     expect(sidebar.projectGroups[0]?.defaultCollapsed).toBe(false)
@@ -198,9 +199,7 @@ describe("read models", () => {
       createdAt: 3,
       updatedAt: 15,
     })
-    state.sidebarProjectOrder = ["project-1"]
-
-    const sidebar = deriveSidebarData(state, new Map())
+    const sidebar = deriveSidebarData(state, new Map(), { sidebarProjectOrder: ["project-1"] })
 
     expect(sidebar.projectGroups.map((group) => group.groupKey)).toEqual(["project-1", "project-2", "project-3"])
   })
@@ -242,10 +241,69 @@ describe("read models", () => {
       lastTurnOutcome: null,
     })
 
-    const sidebar = deriveSidebarData(state, new Map(), 1_000_000)
+    const sidebar = deriveSidebarData(state, new Map(), { nowMs: 1_000_000 })
 
     expect(sidebar.projectGroups[0]?.previewChats.map((chat) => chat.chatId)).toEqual(["chat-1"])
     expect(sidebar.projectGroups[0]?.olderChats.map((chat) => chat.chatId)).toEqual(["chat-2"])
     expect(sidebar.projectGroups[0]?.defaultCollapsed).toBe(false)
   })
+
+  test("disables forking for active and draining chats, but allows pending fork chats", () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-active", {
+      id: "chat-active",
+      projectId: "project-1",
+      title: "Active",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "claude",
+      planMode: false,
+      sessionToken: "session-active",
+      lastTurnOutcome: null,
+    })
+    state.chatsById.set("chat-pending", {
+      id: "chat-pending",
+      projectId: "project-1",
+      title: "Pending fork",
+      createdAt: 2,
+      updatedAt: 2,
+      unread: false,
+      provider: "claude",
+      planMode: false,
+      sessionToken: null,
+      pendingForkSessionToken: "session-parent",
+      lastTurnOutcome: null,
+    })
+    state.chatsById.set("chat-draining", {
+      id: "chat-draining",
+      projectId: "project-1",
+      title: "Draining",
+      createdAt: 3,
+      updatedAt: 3,
+      unread: false,
+      provider: "codex",
+      planMode: false,
+      sessionToken: "thread-1",
+      lastTurnOutcome: null,
+    })
+
+    const sidebar = deriveSidebarData(
+      state,
+      new Map([["chat-active", "running"]]),
+      { drainingChatIds: new Set(["chat-draining"]) }
+    )
+
+    expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-active")?.canFork).toBeUndefined()
+    expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-pending")?.canFork).toBe(true)
+    expect(sidebar.projectGroups[0]?.chats.find((chat) => chat.chatId === "chat-draining")?.canFork).toBeUndefined()
+  })
 })

package/src/server/read-models.ts

@@ -25,6 +25,18 @@ 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
 }
@@ -49,8 +61,14 @@ function getSidebarChatBuckets(chats: SidebarChatRow[], nowMs: number) {
 export function deriveSidebarData(
   state: StoreState,
   activeStatuses: Map<string, KannaStatus>,
-  nowMs = Date.now()
+  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[]>()
   for (const chat of state.chatsById.values()) {
     if (chat.deletedAt) continue
@@ -67,7 +85,7 @@ export function deriveSidebarData(
   const unorderedProjects = allProjects
     .sort((a, b) => b.updatedAt - a.updatedAt)
   const projectById = new Map(unorderedProjects.map((project) => [project.id, project]))
-  const orderedProjects = state.sidebarProjectOrder
+  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))
@@ -90,6 +108,7 @@ export function deriveSidebarData(
         provider: chat.provider,
         lastMessageAt: chat.lastMessageAt,
         hasAutomation: false,
+        canFork: canForkChat(chat, activeStatuses, drainingChatIds) || undefined,
       }))
     const { previewChats, olderChats } = getSidebarChatBuckets(chats, nowMs)
 

package/src/server/server.ts

@@ -60,6 +60,13 @@ export interface StartKannaServerOptions {
   host?: string
   password?: string | null
   strictPort?: boolean
+  /**
+   * When true, the auth layer trusts X-Forwarded-Proto for CSRF origin
+   * checks, redirect URLs, and the Secure cookie flag. The hostname still
+   * comes from the request URL / Host header. Only enable when the server is
+   * reachable solely through a trusted reverse proxy such as cloudflared.
+   */
+  trustProxy?: boolean
   onMigrationProgress?: (message: string) => void
   update?: {
     version: string
@@ -72,7 +79,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 auth = options.password ? createAuthManager(options.password) : null
+  const auth = options.password ? createAuthManager(options.password, { trustProxy: options.trustProxy ?? false }) : null
   const store = new EventStore()
   const diffStore = new DiffStore(store.dataDir)
   const machineDisplayName = getMachineDisplayName()

package/src/server/share.ts

@@ -63,42 +63,10 @@ function createNamedTunnel(token: string, localUrl: string) {
   return tunnel
 }
 
-async function awaitQuickTunnelUrl(tunnel: ShareTunnelProcess) {
-  return await new Promise<string>((resolve, reject) => {
-    let settled = false
-
-    const cleanup = () => {
-      tunnel.off("url", handleUrl)
-      tunnel.off("error", handleError)
-      tunnel.off("exit", handleExit)
-    }
-
-    const settle = (callback: () => void) => {
-      if (settled) return
-      settled = true
-      cleanup()
-      callback()
-    }
-
-    const handleUrl = (url: string) => {
-      settle(() => resolve(normalizePublicUrl(url)))
-    }
-
-    const handleError = (error: Error) => {
-      settle(() => reject(error))
-    }
-
-    const handleExit = (code: number | null, signal: NodeJS.Signals | null) => {
-      settle(() => reject(new Error(`Cloudflare tunnel exited before a public URL was ready (code: ${String(code)}, signal: ${String(signal)})`)))
-    }
-
-    tunnel.once("url", handleUrl)
-    tunnel.once("error", handleError)
-    tunnel.once("exit", handleExit)
-  })
-}
-
-async function awaitNamedTunnelReady(tunnel: ShareTunnelProcess) {
+async function awaitTunnelReady(
+  tunnel: ShareTunnelProcess,
+  { expectUrl }: { expectUrl: boolean },
+) {
   return await new Promise<string | null>((resolve, reject) => {
     let settled = false
 
@@ -121,6 +89,7 @@ async function awaitNamedTunnelReady(tunnel: ShareTunnelProcess) {
     }
 
     const handleConnected = () => {
+      if (expectUrl) return
       settle(() => resolve(null))
     }
 
@@ -129,11 +98,14 @@ async function awaitNamedTunnelReady(tunnel: ShareTunnelProcess) {
     }
 
     const handleExit = (code: number | null, signal: NodeJS.Signals | null) => {
-      settle(() => reject(new Error(`Cloudflare tunnel exited before it was ready (code: ${String(code)}, signal: ${String(signal)})`)))
+      const readyState = expectUrl ? "a public URL was ready" : "it was ready"
+      settle(() => reject(new Error(`Cloudflare tunnel exited before ${readyState} (code: ${String(code)}, signal: ${String(signal)})`)))
     }
 
     tunnel.once("url", handleUrl)
-    tunnel.once("connected", handleConnected)
+    if (!expectUrl) {
+      tunnel.once("connected", handleConnected)
+    }
     tunnel.once("error", handleError)
     tunnel.once("exit", handleExit)
   })
@@ -145,12 +117,11 @@ export async function startShareTunnel(
   deps: ShareTunnelDeps = {},
 ): Promise<StartedShareTunnel> {
   await ensureCloudflaredInstalled(deps)
-  const tunnel = isTokenShareMode(shareMode)
+  const namedTunnel = isTokenShareMode(shareMode)
+  const tunnel = namedTunnel
     ? (deps.createNamedTunnel ?? createNamedTunnel)(shareMode.token, localUrl)
     : (deps.createQuickTunnel ?? ((url) => Tunnel.quick(url)))(localUrl)
-  const publicUrl = isTokenShareMode(shareMode)
-    ? await awaitNamedTunnelReady(tunnel)
-    : await awaitQuickTunnelUrl(tunnel)
+  const publicUrl = await awaitTunnelReady(tunnel, { expectUrl: !namedTunnel })
 
   return {
     publicUrl,

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

@@ -17,6 +17,7 @@ function withSidebarGroupDefaults(group: {
     localPath: string
     provider: "claude" | "codex" | null
     lastMessageAt?: number
+    canFork?: boolean
     hasAutomation: boolean
   }>
 }) {
@@ -739,7 +740,10 @@ describe("ws-router", () => {
 
     const router = createWsRouter({
       store: store as never,
-      agent: { getActiveStatuses: () => new Map() } as never,
+      agent: {
+        getActiveStatuses: () => new Map(),
+        getDrainingChatIds: () => new Set(),
+      } as never,
       terminals: {
         getSnapshot: () => null,
         onEvent: () => () => {},
@@ -863,12 +867,16 @@ describe("ws-router", () => {
     })
 
     const setSidebarProjectOrderCalls: string[][] = []
+    let sidebarProjectOrder: string[] = []
     const router = createWsRouter({
       store: {
         state,
+        getSidebarProjectOrder() {
+          return [...sidebarProjectOrder]
+        },
         async setSidebarProjectOrder(projectIds: string[]) {
           setSidebarProjectOrderCalls.push(projectIds)
-          state.sidebarProjectOrder = [...projectIds]
+          sidebarProjectOrder = [...projectIds]
         },
       } as never,
       agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
@@ -938,6 +946,135 @@ describe("ws-router", () => {
     })
   })
 
+  test("forks a chat through the agent and rebroadcasts the sidebar snapshot", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: "claude",
+      planMode: false,
+      sessionToken: "session-1",
+      pendingForkSessionToken: null,
+      lastTurnOutcome: null,
+    })
+
+    const forkChatCalls: string[] = []
+    const router = createWsRouter({
+      store: { state } as never,
+      agent: {
+        getActiveStatuses: () => new Map(),
+        getDrainingChatIds: () => new Set(),
+          forkChat: async (chatId: string) => {
+          forkChatCalls.push(chatId)
+          state.chatsById.set("chat-fork-1", {
+            id: "chat-fork-1",
+            projectId: "project-1",
+            title: "Fork: Chat",
+            createdAt: 2,
+            updatedAt: 2,
+            unread: false,
+            provider: "claude",
+            planMode: false,
+            sessionToken: null,
+            pendingForkSessionToken: "session-1",
+            lastTurnOutcome: null,
+          })
+          return { chatId: "chat-fork-1" }
+        },
+      } as never,
+      terminals: {
+        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()
+    router.handleOpen(ws as never)
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "sidebar-sub-1",
+        topic: { type: "sidebar" },
+      })
+    )
+
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "fork-1",
+        command: { type: "chat.fork", chatId: "chat-1" },
+      })
+    )
+
+    expect(forkChatCalls).toEqual(["chat-1"])
+    expect(ws.sent.at(-2)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "fork-1",
+      result: { chatId: "chat-fork-1" },
+    })
+    expect(ws.sent.at(-1)).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id: "sidebar-sub-1",
+      snapshot: {
+        type: "sidebar",
+        data: {
+          projectGroups: [withSidebarGroupDefaults({
+            groupKey: "project-1",
+            localPath: "/tmp/project",
+            chats: [{
+              _id: "chat-fork-1",
+              _creationTime: 2,
+              chatId: "chat-fork-1",
+              title: "Fork: Chat",
+              status: "idle",
+              unread: false,
+              localPath: "/tmp/project",
+              provider: "claude",
+              canFork: true,
+              hasAutomation: false,
+            }, {
+              _id: "chat-1",
+              _creationTime: 1,
+              chatId: "chat-1",
+              title: "Chat",
+              status: "idle",
+              unread: false,
+              localPath: "/tmp/project",
+              provider: "claude",
+              canFork: true,
+              hasAutomation: false,
+            }],
+          })],
+        },
+      },
+    })
+  })
+
   test("prunes stale empty chats during explicit maintenance runs", async () => {
     const state = createEmptyState()
     state.projectsById.set("project-1", {

package/src/server/ws-router.ts

@@ -126,6 +126,12 @@ interface SnapshotComputationCache {
   }
 }
 
+function getSidebarProjectOrder(store: EventStore) {
+  return typeof store.getSidebarProjectOrder === "function"
+    ? store.getSidebarProjectOrder()
+    : []
+}
+
 function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
   const payload = JSON.stringify(message)
   ws.send(payload)
@@ -300,7 +306,10 @@ export function createWsRouter({
     }
 
     const startedAt = performance.now()
-    const data = deriveSidebarData(store.state, agent.getActiveStatuses())
+    const data = deriveSidebarData(store.state, agent.getActiveStatuses(), {
+      sidebarProjectOrder: getSidebarProjectOrder(store),
+      drainingChatIds: agent.getDrainingChatIds(),
+    })
     if (isSendToStartingProfilingEnabled()) {
       const totalChats = data.projectGroups.reduce((count, group) => count + group.chats.length, 0)
       console.log("[kanna/send->starting][server]", JSON.stringify({
@@ -805,6 +814,12 @@ export function createWsRouter({
           await broadcastChatAndSidebar(chat.id)
           return
         }
+        case "chat.fork": {
+          const result = await agent.forkChat(command.chatId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          await broadcastFilteredSnapshots({ includeSidebar: true })
+          return
+        }
         case "chat.rename": {
           await store.renameChat(command.chatId, command.title)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })

package/src/shared/dev-ports.ts

@@ -1,5 +1,5 @@
 import type { ShareMode } from "./share"
-import { isShareEnabled } from "./share"
+import { assertNoHostOverride, getShareCliFlag, isShareEnabled } from "./share"
 
 export const DEFAULT_DEV_CLIENT_PORT = 5174
 
@@ -89,14 +89,12 @@ export function parseDevArgs(args: string[], localHostname: string): DevArgResol
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index]
     if (arg === "--share") {
-      if (sawHost) throw new Error("--share cannot be used with --host")
-      if (sawRemote) throw new Error("--share cannot be used with --remote")
+      assertNoHostOverride("--share", sawHost, sawRemote)
       share = "quick"
       continue
     }
     if (arg === "--cloudflared") {
-      if (sawHost) throw new Error("--cloudflared cannot be used with --host")
-      if (sawRemote) throw new Error("--cloudflared cannot be used with --remote")
+      assertNoHostOverride("--cloudflared", sawHost, sawRemote)
       const next = args[index + 1]
       if (!next || next.startsWith("-")) throw new Error("Missing value for --cloudflared")
       share = { kind: "token", token: next }
@@ -105,7 +103,7 @@ export function parseDevArgs(args: string[], localHostname: string): DevArgResol
     }
     if (arg === "--remote") {
       if (isShareEnabled(share)) {
-        throw new Error(typeof share === "string" ? "--share cannot be used with --remote" : "--cloudflared cannot be used with --remote")
+        throw new Error(`${getShareCliFlag(share)} cannot be used with --remote`)
       }
       sawRemote = true
       backendTargetHost = "127.0.0.1"
@@ -117,7 +115,7 @@ export function parseDevArgs(args: string[], localHostname: string): DevArgResol
     const next = args[index + 1]
     if (!next || next.startsWith("-")) continue
     if (isShareEnabled(share)) {
-      throw new Error(typeof share === "string" ? "--share cannot be used with --host" : "--cloudflared cannot be used with --host")
+      throw new Error(`${getShareCliFlag(share)} cannot be used with --host`)
     }
     sawHost = true
     hosts.add(next)

package/src/shared/protocol.ts

@@ -82,6 +82,7 @@ export type ClientCommand =
       editor?: EditorOpenSettings
     }
   | { type: "chat.create"; projectId: string }
+  | { type: "chat.fork"; chatId: string }
   | { type: "chat.rename"; chatId: string; title: string }
   | { type: "chat.delete"; chatId: string }
   | { type: "chat.setDraftProtection"; chatIds: string[] }

package/src/shared/share.ts

@@ -3,6 +3,8 @@ export type ShareMode = false | "quick" | {
   token: string
 }
 
+export type ShareCliFlag = "--share" | "--cloudflared"
+
 export function isShareEnabled(share: ShareMode): share is Exclude<ShareMode, false> {
   return share !== false
 }
@@ -10,3 +12,16 @@ export function isShareEnabled(share: ShareMode): share is Exclude<ShareMode, fa
 export function isTokenShareMode(share: ShareMode): share is { kind: "token"; token: string } {
   return typeof share === "object" && share !== null && share.kind === "token"
 }
+
+export function getShareCliFlag(share: Exclude<ShareMode, false>): ShareCliFlag {
+  return isTokenShareMode(share) ? "--cloudflared" : "--share"
+}
+
+export function assertNoHostOverride(shareFlag: ShareCliFlag, sawHost: boolean, sawRemote: boolean) {
+  if (sawHost) {
+    throw new Error(`${shareFlag} cannot be used with --host`)
+  }
+  if (sawRemote) {
+    throw new Error(`${shareFlag} cannot be used with --remote`)
+  }
+}

package/src/shared/types.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test"
+import {
+  normalizeClaudeModelId,
+  normalizeCodexModelId,
+  supportsClaudeMaxReasoningEffort,
+} from "./types"
+
+describe("shared model normalization", () => {
+  test("normalizes Claude aliases via the provider catalog", () => {
+    expect(normalizeClaudeModelId("opus")).toBe("claude-opus-4-7")
+    expect(normalizeClaudeModelId("sonnet")).toBe("claude-sonnet-4-6")
+    expect(normalizeClaudeModelId("haiku")).toBe("claude-haiku-4-5-20251001")
+  })
+
+  test("normalizes legacy Codex aliases via the provider catalog", () => {
+    expect(normalizeCodexModelId("gpt-5-codex")).toBe("gpt-5.3-codex")
+  })
+
+  test("uses declarative metadata for Claude max-effort support", () => {
+    expect(supportsClaudeMaxReasoningEffort("claude-opus-4-7")).toBe(true)
+    expect(supportsClaudeMaxReasoningEffort("opus")).toBe(true)
+    expect(supportsClaudeMaxReasoningEffort("claude-sonnet-4-6")).toBe(false)
+  })
+})