kanna-code 0.1.3 → 0.2.0

package/src/server/event-store.ts

@@ -2,7 +2,7 @@ import { appendFile, mkdir } from "node:fs/promises"
 import { homedir } from "node:os"
 import path from "node:path"
 import { getDataDir, LOG_PREFIX } from "../shared/branding"
-import type { TranscriptEntry } from "../shared/types"
+import type { AgentProvider, TranscriptEntry } from "../shared/types"
 import { STORE_VERSION } from "../shared/types"
 import {
   type ChatEvent,
@@ -29,6 +29,7 @@ export class EventStore {
   readonly dataDir = DATA_DIR
   readonly state: StoreState = createEmptyState()
   private writeChain = Promise.resolve()
+  private storageReset = false
 
   async initialize() {
     await mkdir(DATA_DIR, { recursive: true })
@@ -50,14 +51,31 @@ export class EventStore {
     }
   }
 
+  private async clearStorage() {
+    if (this.storageReset) return
+    this.storageReset = true
+    this.resetState()
+    await Promise.all([
+      Bun.write(SNAPSHOT_PATH, ""),
+      Bun.write(PROJECTS_LOG, ""),
+      Bun.write(CHATS_LOG, ""),
+      Bun.write(MESSAGES_LOG, ""),
+      Bun.write(TURNS_LOG, ""),
+    ])
+  }
+
   private async loadSnapshot() {
     const file = Bun.file(SNAPSHOT_PATH)
     if (!(await file.exists())) return
 
     try {
-      const parsed = (await file.json()) as SnapshotFile
+      const text = await file.text()
+      if (!text.trim()) return
+      const parsed = JSON.parse(text) as SnapshotFile
       if (parsed.v !== STORE_VERSION) {
-        throw new Error(`Unsupported snapshot version ${String(parsed.v)}`)
+        console.warn(`${LOG_PREFIX} Resetting local chat history for store version ${STORE_VERSION}`)
+        await this.clearStorage()
+        return
       }
       for (const project of parsed.projects) {
         this.state.projectsById.set(project.id, { ...project })
@@ -70,8 +88,8 @@ export class EventStore {
         this.state.messagesByChatId.set(messageSet.chatId, cloneTranscriptEntries(messageSet.entries))
       }
     } catch (error) {
-      console.warn(`${LOG_PREFIX} Failed to load snapshot, rebuilding from logs:`, error)
-      this.resetState()
+      console.warn(`${LOG_PREFIX} Failed to load snapshot, resetting local history:`, error)
+      await this.clearStorage()
     }
   }
 
@@ -83,9 +101,13 @@ export class EventStore {
   }
 
   private async replayLogs() {
+    if (this.storageReset) return
     await this.replayLog<ProjectEvent>(PROJECTS_LOG)
+    if (this.storageReset) return
     await this.replayLog<ChatEvent>(CHATS_LOG)
+    if (this.storageReset) return
     await this.replayLog<MessageEvent>(MESSAGES_LOG)
+    if (this.storageReset) return
     await this.replayLog<TurnEvent>(TURNS_LOG)
   }
 
@@ -108,14 +130,21 @@ export class EventStore {
       const line = lines[index].trim()
       if (!line) continue
       try {
-        const event = JSON.parse(line) as TEvent
-        this.applyEvent(event)
+        const event = JSON.parse(line) as Partial<StoreEvent>
+        if (event.v !== STORE_VERSION) {
+          console.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
+          await this.clearStorage()
+          return
+        }
+        this.applyEvent(event as StoreEvent)
       } catch (error) {
         if (index === lastNonEmpty) {
           console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
           return
         }
-        throw error
+        console.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, error)
+        await this.clearStorage()
+        return
       }
     }
   }
@@ -150,8 +179,9 @@ export class EventStore {
           title: event.title,
           createdAt: event.timestamp,
           updatedAt: event.timestamp,
+          provider: null,
           planMode: false,
-          resumeSessionId: null,
+          sessionToken: null,
           lastTurnOutcome: null,
         }
         this.state.chatsById.set(chat.id, chat)
@@ -171,6 +201,13 @@ export class EventStore {
         chat.updatedAt = event.timestamp
         break
       }
+      case "chat_provider_set": {
+        const chat = this.state.chatsById.get(event.chatId)
+        if (!chat) break
+        chat.provider = event.provider
+        chat.updatedAt = event.timestamp
+        break
+      }
       case "chat_plan_mode_set": {
         const chat = this.state.chatsById.get(event.chatId)
         if (!chat) break
@@ -181,15 +218,8 @@ export class EventStore {
       case "message_appended": {
         const chat = this.state.chatsById.get(event.chatId)
         if (chat) {
-          // Only update lastMessageAt for user-sent messages so the sidebar
-          // sorts by "last sent" rather than "last received".
-          try {
-            const parsed = JSON.parse(event.entry.message)
-            if (parsed.type === "user_prompt") {
-              chat.lastMessageAt = event.entry.createdAt
-            }
-          } catch {
-            // non-JSON entry, skip
+          if (event.entry.kind === "user_prompt") {
+            chat.lastMessageAt = event.entry.createdAt
           }
           chat.updatedAt = Math.max(chat.updatedAt, event.entry.createdAt)
         }
@@ -225,10 +255,10 @@ export class EventStore {
         chat.lastTurnOutcome = "cancelled"
         break
       }
-      case "resume_session_set": {
+      case "session_token_set": {
         const chat = this.state.chatsById.get(event.chatId)
         if (!chat) break
-        chat.resumeSessionId = event.sessionId
+        chat.sessionToken = event.sessionToken
         chat.updatedAt = event.timestamp
         break
       }
@@ -326,6 +356,19 @@ export class EventStore {
     await this.append(CHATS_LOG, event)
   }
 
+  async setChatProvider(chatId: string, provider: AgentProvider) {
+    const chat = this.requireChat(chatId)
+    if (chat.provider === provider) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_provider_set",
+      timestamp: Date.now(),
+      chatId,
+      provider,
+    }
+    await this.append(CHATS_LOG, event)
+  }
+
   async setPlanMode(chatId: string, planMode: boolean) {
     const chat = this.requireChat(chatId)
     if (chat.planMode === planMode) return
@@ -396,15 +439,15 @@ export class EventStore {
     await this.append(TURNS_LOG, event)
   }
 
-  async setResumeSession(chatId: string, sessionId: string | null) {
+  async setSessionToken(chatId: string, sessionToken: string | null) {
     const chat = this.requireChat(chatId)
-    if (chat.resumeSessionId === sessionId) return
+    if (chat.sessionToken === sessionToken) return
     const event: TurnEvent = {
       v: STORE_VERSION,
-      type: "resume_session_set",
+      type: "session_token_set",
       timestamp: Date.now(),
       chatId,
-      sessionId,
+      sessionToken,
     }
     await this.append(TURNS_LOG, event)
   }
@@ -460,19 +503,23 @@ export class EventStore {
         entries: cloneTranscriptEntries(entries),
       })),
     }
+
     await Bun.write(SNAPSHOT_PATH, JSON.stringify(snapshot, null, 2))
-    await Bun.write(PROJECTS_LOG, "")
-    await Bun.write(CHATS_LOG, "")
-    await Bun.write(MESSAGES_LOG, "")
-    await Bun.write(TURNS_LOG, "")
+    await Promise.all([
+      Bun.write(PROJECTS_LOG, ""),
+      Bun.write(CHATS_LOG, ""),
+      Bun.write(MESSAGES_LOG, ""),
+      Bun.write(TURNS_LOG, ""),
+    ])
   }
 
   private async shouldCompact() {
-    const files = [PROJECTS_LOG, CHATS_LOG, MESSAGES_LOG, TURNS_LOG]
-    let total = 0
-    for (const filePath of files) {
-      total += Bun.file(filePath).size
-    }
-    return total >= COMPACTION_THRESHOLD_BYTES
+    const sizes = await Promise.all([
+      Bun.file(PROJECTS_LOG).size,
+      Bun.file(CHATS_LOG).size,
+      Bun.file(MESSAGES_LOG).size,
+      Bun.file(TURNS_LOG).size,
+    ])
+    return sizes.reduce((total, size) => total + size, 0) >= COMPACTION_THRESHOLD_BYTES
   }
 }

package/src/server/events.ts

@@ -1,4 +1,4 @@
-import type { ProjectSummary, TranscriptEntry } from "../shared/types"
+import type { AgentProvider, ProjectSummary, TranscriptEntry } from "../shared/types"
 
 export interface ProjectRecord extends ProjectSummary {
   deletedAt?: number
@@ -11,8 +11,9 @@ export interface ChatRecord {
   createdAt: number
   updatedAt: number
   deletedAt?: number
+  provider: AgentProvider | null
   planMode: boolean
-  resumeSessionId: string | null
+  sessionToken: string | null
   lastMessageAt?: number
   lastTurnOutcome: "success" | "failed" | "cancelled" | null
 }
@@ -25,7 +26,7 @@ export interface StoreState {
 }
 
 export interface SnapshotFile {
-  v: 1
+  v: 2
   generatedAt: number
   projects: ProjectRecord[]
   chats: ChatRecord[]
@@ -33,14 +34,14 @@ export interface SnapshotFile {
 }
 
 export type ProjectEvent = {
-  v: 1
+  v: 2
   type: "project_opened"
   timestamp: number
   projectId: string
   localPath: string
   title: string
 } | {
-  v: 1
+  v: 2
   type: "project_removed"
   timestamp: number
   projectId: string
@@ -48,7 +49,7 @@ export type ProjectEvent = {
 
 export type ChatEvent =
   | {
-      v: 1
+      v: 2
       type: "chat_created"
       timestamp: number
       chatId: string
@@ -56,20 +57,27 @@ export type ChatEvent =
       title: string
     }
   | {
-      v: 1
+      v: 2
       type: "chat_renamed"
       timestamp: number
       chatId: string
       title: string
     }
   | {
-      v: 1
+      v: 2
       type: "chat_deleted"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
+      v: 2
+      type: "chat_provider_set"
+      timestamp: number
+      chatId: string
+      provider: AgentProvider
+    }
+  | {
+      v: 2
       type: "chat_plan_mode_set"
       timestamp: number
       chatId: string
@@ -77,7 +85,7 @@ export type ChatEvent =
     }
 
 export type MessageEvent = {
-  v: 1
+  v: 2
   type: "message_appended"
   timestamp: number
   chatId: string
@@ -86,36 +94,36 @@ export type MessageEvent = {
 
 export type TurnEvent =
   | {
-      v: 1
+      v: 2
       type: "turn_started"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
+      v: 2
       type: "turn_finished"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
+      v: 2
       type: "turn_failed"
       timestamp: number
       chatId: string
       error: string
     }
   | {
-      v: 1
+      v: 2
       type: "turn_cancelled"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
-      type: "resume_session_set"
+      v: 2
+      type: "session_token_set"
       timestamp: number
       chatId: string
-      sessionId: string | null
+      sessionToken: string | null
     }
 
 export type StoreEvent = ProjectEvent | ChatEvent | MessageEvent | TurnEvent

package/src/server/harness-types.ts

@@ -0,0 +1,19 @@
+import type { AccountInfo, AgentProvider, NormalizedToolCall, TranscriptEntry } from "../shared/types"
+
+export interface HarnessEvent {
+  type: "transcript" | "session_token"
+  entry?: TranscriptEntry
+  sessionToken?: string
+}
+
+export interface HarnessToolRequest {
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+}
+
+export interface HarnessTurn {
+  provider: AgentProvider
+  stream: AsyncIterable<HarnessEvent>
+  getAccountInfo?: () => Promise<AccountInfo | null>
+  interrupt: () => Promise<void>
+  close: () => void
+}

package/src/server/provider-catalog.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test"
+import {
+  codexServiceTierFromModelOptions,
+  normalizeClaudeModelOptions,
+  normalizeCodexModelOptions,
+} from "./provider-catalog"
+
+describe("provider catalog normalization", () => {
+  test("maps legacy Claude effort into shared model options", () => {
+    expect(normalizeClaudeModelOptions(undefined, "max")).toEqual({
+      reasoningEffort: "max",
+    })
+  })
+
+  test("normalizes Codex model options and fast mode defaults", () => {
+    expect(normalizeCodexModelOptions(undefined)).toEqual({
+      reasoningEffort: "high",
+      fastMode: false,
+    })
+
+    const normalized = normalizeCodexModelOptions({
+      codex: {
+        reasoningEffort: "xhigh",
+        fastMode: true,
+      },
+    })
+
+    expect(normalized).toEqual({
+      reasoningEffort: "xhigh",
+      fastMode: true,
+    })
+    expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
+  })
+})

package/src/server/provider-catalog.ts

@@ -0,0 +1,77 @@
+import type {
+  AgentProvider,
+  ClaudeModelOptions,
+  CodexModelOptions,
+  ModelOptions,
+  ProviderCatalogEntry,
+  ProviderModelOption,
+  ServiceTier,
+} from "../shared/types"
+import {
+  DEFAULT_CLAUDE_MODEL_OPTIONS,
+  DEFAULT_CODEX_MODEL_OPTIONS,
+  PROVIDERS,
+  isClaudeReasoningEffort,
+  isCodexReasoningEffort,
+} from "../shared/types"
+
+const HARD_CODED_CODEX_MODELS: ProviderModelOption[] = [
+  { id: "gpt-5.4", label: "GPT-5.4", supportsEffort: false },
+  { id: "gpt-5.3-codex", label: "GPT-5.3 Codex", supportsEffort: false },
+  { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", supportsEffort: false },
+]
+
+export const SERVER_PROVIDERS: ProviderCatalogEntry[] = PROVIDERS.map((provider) =>
+  provider.id === "codex"
+    ? {
+        ...provider,
+        defaultModel: "gpt-5.4",
+        models: HARD_CODED_CODEX_MODELS,
+      }
+    : provider
+)
+
+export function getServerProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
+  const entry = SERVER_PROVIDERS.find((candidate) => candidate.id === provider)
+  if (!entry) {
+    throw new Error(`Unknown provider: ${provider}`)
+  }
+  return entry
+}
+
+export function normalizeServerModel(provider: AgentProvider, model?: string): string {
+  const catalog = getServerProviderCatalog(provider)
+  if (model && catalog.models.some((candidate) => candidate.id === model)) {
+    return model
+  }
+  return catalog.defaultModel
+}
+
+export function normalizeClaudeModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): ClaudeModelOptions {
+  const reasoningEffort = modelOptions?.claude?.reasoningEffort
+  return {
+    reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isClaudeReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
+  }
+}
+
+export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): CodexModelOptions {
+  const reasoningEffort = modelOptions?.codex?.reasoningEffort
+  return {
+    reasoningEffort: isCodexReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isCodexReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CODEX_MODEL_OPTIONS.reasoningEffort,
+    fastMode: typeof modelOptions?.codex?.fastMode === "boolean"
+      ? modelOptions.codex.fastMode
+      : DEFAULT_CODEX_MODEL_OPTIONS.fastMode,
+  }
+}
+
+export function codexServiceTierFromModelOptions(modelOptions: CodexModelOptions): ServiceTier | undefined {
+  return modelOptions.fastMode ? "fast" : undefined
+}

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

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test"
+import { deriveChatSnapshot, deriveSidebarData } from "./read-models"
+import { createEmptyState } from "./events"
+
+describe("read models", () => {
+  test("include provider data in sidebar rows", () => {
+    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-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      provider: "codex",
+      planMode: false,
+      sessionToken: "thread-1",
+      lastTurnOutcome: null,
+    })
+
+    const sidebar = deriveSidebarData(state, new Map())
+    expect(sidebar.projectGroups[0]?.chats[0]?.provider).toBe("codex")
+  })
+
+  test("includes available providers in chat snapshots", () => {
+    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-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      provider: "claude",
+      planMode: true,
+      sessionToken: "session-1",
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1")
+    expect(chat?.runtime.provider).toBe("claude")
+    expect(chat?.availableProviders.length).toBeGreaterThan(1)
+    expect(chat?.availableProviders.find((provider) => provider.id === "codex")?.models.map((model) => model.id)).toEqual([
+      "gpt-5.4",
+      "gpt-5.3-codex",
+      "gpt-5.3-codex-spark",
+    ])
+  })
+})

package/src/server/read-models.ts

@@ -10,6 +10,7 @@ import type {
 import type { ChatRecord, StoreState } from "./events"
 import { cloneTranscriptEntries } from "./events"
 import { resolveLocalPath } from "./paths"
+import { SERVER_PROVIDERS } from "./provider-catalog"
 
 export function deriveStatus(chat: ChatRecord, activeStatus?: KannaStatus): KannaStatus {
   if (activeStatus) return activeStatus
@@ -36,6 +37,7 @@ export function deriveSidebarData(
         title: chat.title,
         status: deriveStatus(chat, activeStatuses.get(chat.id)),
         localPath: project.localPath,
+        provider: chat.provider,
         lastMessageAt: chat.lastMessageAt,
         hasAutomation: false,
       }))
@@ -109,12 +111,14 @@ export function deriveChatSnapshot(
     localPath: project.localPath,
     title: chat.title,
     status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    provider: chat.provider,
     planMode: chat.planMode,
-    resumeSessionId: chat.resumeSessionId,
+    sessionToken: chat.sessionToken,
   }
 
   return {
     runtime,
     messages: cloneTranscriptEntries(state.messagesByChatId.get(chat.id) ?? []),
+    availableProviders: [...SERVER_PROVIDERS],
   }
 }

package/src/shared/protocol.ts

@@ -1,4 +1,4 @@
-import type { ChatSnapshot, LocalProjectsSnapshot, SidebarData } from "./types"
+import type { AgentProvider, ChatSnapshot, LocalProjectsSnapshot, ModelOptions, SidebarData } from "./types"
 
 export type SubscriptionTopic =
   | { type: "sidebar" }
@@ -13,7 +13,17 @@ export type ClientCommand =
   | { type: "chat.create"; projectId: string }
   | { type: "chat.rename"; chatId: string; title: string }
   | { type: "chat.delete"; chatId: string }
-  | { type: "chat.send"; chatId?: string; projectId?: string; content: string; model?: string; effort?: string; planMode?: boolean }
+  | {
+      type: "chat.send"
+      chatId?: string
+      projectId?: string
+      provider?: AgentProvider
+      content: string
+      model?: string
+      modelOptions?: ModelOptions
+      effort?: string
+      planMode?: boolean
+    }
   | { type: "chat.cancel"; chatId: string }
   | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }