kanna-code 0.32.4 → 0.33.0

package/src/server/codex-app-server.ts

@@ -34,6 +34,8 @@ import {
   type ThreadItem,
   type ThreadResumeParams,
   type ThreadResumeResponse,
+  type ThreadForkParams,
+  type ThreadForkResponse,
   type ThreadStartParams,
   type ThreadStartResponse,
   type ThreadTokenUsageUpdatedNotification,
@@ -118,6 +120,7 @@ export interface StartCodexSessionArgs {
   model: string
   serviceTier?: ServiceTier
   sessionToken: string | null
+  pendingForkSessionToken?: string | null
 }
 
 export interface StartCodexTurnArgs {
@@ -745,7 +748,7 @@ export class CodexAppServerManager {
 
   async startSession(args: StartCodexSessionArgs) {
     const existing = this.sessions.get(args.chatId)
-    if (existing && !existing.closed && existing.cwd === args.cwd) {
+    if (existing && !existing.closed && existing.cwd === args.cwd && !args.pendingForkSessionToken) {
       return
     }
 
@@ -791,8 +794,18 @@ export class CodexAppServerManager {
       persistExtendedHistory: false,
     } satisfies ThreadStartParams
 
-    let response: ThreadStartResponse | ThreadResumeResponse
-    if (args.sessionToken) {
+    let response: ThreadStartResponse | ThreadResumeResponse | ThreadForkResponse
+    if (args.pendingForkSessionToken) {
+      response = await this.sendRequest<ThreadForkResponse>(context, "thread/fork", {
+        threadId: args.pendingForkSessionToken,
+        model: args.model,
+        cwd: args.cwd,
+        serviceTier: args.serviceTier,
+        approvalPolicy: "never",
+        sandbox: "danger-full-access",
+        persistExtendedHistory: false,
+      } satisfies ThreadForkParams)
+    } else if (args.sessionToken) {
       try {
         response = await this.sendRequest<ThreadResumeResponse>(context, "thread/resume", {
           threadId: args.sessionToken,
@@ -815,6 +828,7 @@ export class CodexAppServerManager {
     }
 
     context.sessionToken = response.thread.id
+    return context.sessionToken
   }
 
   async startTurn(args: StartCodexTurnArgs): Promise<HarnessTurn> {

package/src/server/diff-store.ts

@@ -121,15 +121,6 @@ type SelectedBranch =
       remoteRef?: string
     }
 
-async function fileExists(filePath: string) {
-  try {
-    await stat(filePath)
-    return true
-  } catch {
-    return false
-  }
-}
-
 async function runGit(args: string[], cwd: string) {
   const process = Bun.spawn(["git", "-C", cwd, ...args], {
     stdout: "pipe",

package/src/server/event-store.test.ts

@@ -511,4 +511,30 @@ describe("EventStore", () => {
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
   })
+
+  test("forks a chat with copied transcript and pending fork session token", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    const project = await store.openProject("/tmp/project")
+    const source = await store.createChat(project.id)
+    await store.setChatProvider(source.id, "claude")
+    await store.setPlanMode(source.id, true)
+    await store.setSessionToken(source.id, "session-1")
+    await store.appendMessage(source.id, entry("user_prompt", source.createdAt + 1, { content: "analyze this" }))
+    await store.appendMessage(source.id, entry("assistant_text", source.createdAt + 2, { text: "done" }))
+
+    const forked = await store.forkChat(source.id)
+
+    expect(forked.id).not.toBe(source.id)
+    expect(forked.title).toBe("Fork: New Chat")
+    expect(forked.provider).toBe("claude")
+    expect(forked.planMode).toBe(true)
+    expect(forked.sessionToken).toBeNull()
+    expect(forked.pendingForkSessionToken).toBe("session-1")
+    expect(forked.lastTurnOutcome).toBeNull()
+    expect(forked.lastMessageAt).toBeUndefined()
+    expect(store.getMessages(forked.id)).toEqual(store.getMessages(source.id))
+  })
 })

package/src/server/event-store.ts

@@ -94,6 +94,8 @@ function getReplayEventPriority(event: StoreEvent) {
       return 5
     case "session_token_set":
       return 6
+    case "pending_fork_session_token_set":
+      return 6
     case "turn_cancelled":
       return 7
     case "turn_finished":
@@ -130,6 +132,12 @@ function getHistorySnapshot(page: TranscriptPageResult, recentLimit: number): Ch
   }
 }
 
+function getForkedChatTitle(title: string) {
+  const trimmed = title.trim()
+  if (!trimmed) return "Fork: New Chat"
+  return trimmed.startsWith("Fork: ") ? trimmed : `Fork: ${trimmed}`
+}
+
 export class EventStore {
   readonly dataDir: string
   readonly state: StoreState = createEmptyState()
@@ -220,6 +228,7 @@ export class EventStore {
         this.state.chatsById.set(chat.id, {
           ...chat,
           unread: chat.unread ?? false,
+          pendingForkSessionToken: chat.pendingForkSessionToken ?? null,
         })
       }
       this.legacySidebarProjectOrder = normalizeSidebarProjectOrder(parsed.sidebarProjectOrder)
@@ -443,6 +452,7 @@ export class EventStore {
           provider: null,
           planMode: false,
           sessionToken: null,
+          pendingForkSessionToken: null,
           hasMessages: false,
           lastTurnOutcome: null,
         }
@@ -555,6 +565,13 @@ export class EventStore {
         chat.updatedAt = event.timestamp
         break
       }
+      case "pending_fork_session_token_set": {
+        const chat = this.state.chatsById.get(event.chatId)
+        if (!chat) break
+        chat.pendingForkSessionToken = event.pendingForkSessionToken
+        chat.updatedAt = event.timestamp
+        break
+      }
     }
   }
 
@@ -677,6 +694,50 @@ export class EventStore {
     return this.state.chatsById.get(chatId)!
   }
 
+  async forkChat(sourceChatId: string) {
+    const sourceChat = this.requireChat(sourceChatId)
+    const sourceSessionToken = sourceChat.sessionToken ?? sourceChat.pendingForkSessionToken ?? null
+    if (!sourceChat.provider || !sourceSessionToken) {
+      throw new Error("Chat cannot be forked")
+    }
+
+    const chatId = crypto.randomUUID()
+    const createdAt = Date.now()
+    const createEvent: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_created",
+      timestamp: createdAt,
+      chatId,
+      projectId: sourceChat.projectId,
+      title: getForkedChatTitle(sourceChat.title),
+    }
+    await this.append(this.chatsLogPath, createEvent)
+    await this.setChatProvider(chatId, sourceChat.provider)
+    await this.setPlanMode(chatId, sourceChat.planMode)
+    await this.setPendingForkSessionToken(chatId, sourceSessionToken)
+
+    const sourceEntries = this.getMessages(sourceChatId)
+    if (sourceEntries.length > 0) {
+      const transcriptPath = this.transcriptPath(chatId)
+      const payload = sourceEntries.map((entry) => JSON.stringify(entry)).join("\n")
+      this.writeChain = this.writeChain.then(async () => {
+        await mkdir(this.transcriptsDir, { recursive: true })
+        await writeFile(transcriptPath, `${payload}\n`, "utf8")
+        const chat = this.state.chatsById.get(chatId)
+        if (chat) {
+          chat.hasMessages = true
+          chat.updatedAt = Math.max(chat.updatedAt, createdAt)
+        }
+        if (this.cachedTranscript?.chatId === chatId) {
+          this.cachedTranscript = { chatId, entries: cloneTranscriptEntries(sourceEntries) }
+        }
+      })
+      await this.writeChain
+    }
+
+    return this.state.chatsById.get(chatId)!
+  }
+
   async renameChat(chatId: string, title: string) {
     const trimmed = title.trim()
     if (!trimmed) return
@@ -911,6 +972,19 @@ export class EventStore {
     await this.append(this.turnsLogPath, event)
   }
 
+  async setPendingForkSessionToken(chatId: string, pendingForkSessionToken: string | null) {
+    const chat = this.requireChat(chatId)
+    if ((chat.pendingForkSessionToken ?? null) === pendingForkSessionToken) return
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "pending_fork_session_token_set",
+      timestamp: Date.now(),
+      chatId,
+      pendingForkSessionToken,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
   getProject(projectId: string) {
     const project = this.state.projectsById.get(projectId)
     if (!project || project.deletedAt) return null

package/src/server/events.ts

@@ -15,6 +15,7 @@ export interface ChatRecord {
   provider: AgentProvider | null
   planMode: boolean
   sessionToken: string | null
+  pendingForkSessionToken?: string | null
   hasMessages?: boolean
   lastMessageAt?: number
   lastTurnOutcome: "success" | "failed" | "cancelled" | null
@@ -152,6 +153,13 @@ export type TurnEvent =
       chatId: string
       sessionToken: string | null
     }
+  | {
+      v: 2
+      type: "pending_fork_session_token_set"
+      timestamp: number
+      chatId: string
+      pendingForkSessionToken: string | null
+    }
 
 export type StoreEvent = ProjectEvent | ChatEvent | MessageEvent | QueuedMessageEvent | TurnEvent
 

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

@@ -29,6 +29,7 @@ describe("read models", () => {
     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)
@@ -246,4 +247,63 @@ describe("read models", () => {
     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
 }
@@ -52,9 +64,11 @@ export function deriveSidebarData(
   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
@@ -94,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/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: () => () => {},
@@ -942,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

@@ -308,6 +308,7 @@ export function createWsRouter({
     const startedAt = performance.now()
     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)
@@ -813,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/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/types.ts

@@ -276,6 +276,7 @@ export interface SidebarChatRow {
   provider: AgentProvider | null
   lastMessageAt?: number
   hasAutomation: boolean
+  canFork?: boolean
 }
 
 export interface SidebarProjectGroup {