kanna-code 0.15.0 → 0.17.0

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

@@ -1,16 +1,39 @@
 import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import type { TranscriptEntry } from "../shared/types"
+import type { SnapshotFile } from "./events"
 import { EventStore } from "./event-store"
 
 const originalRuntimeProfile = process.env.KANNA_RUNTIME_PROFILE
+const tempDirs: string[] = []
 
-afterEach(() => {
+afterEach(async () => {
   if (originalRuntimeProfile === undefined) {
     delete process.env.KANNA_RUNTIME_PROFILE
   } else {
     process.env.KANNA_RUNTIME_PROFILE = originalRuntimeProfile
   }
+
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
 })
 
+async function createTempDataDir() {
+  const dir = await mkdtemp(join(tmpdir(), "kanna-event-store-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+function entry(kind: "user_prompt" | "assistant_text", createdAt: number, extra: Record<string, unknown> = {}): TranscriptEntry {
+  const base = { _id: `${kind}-${createdAt}`, createdAt }
+  if (kind === "user_prompt") {
+    return { ...base, kind, content: String(extra.content ?? "") }
+  }
+  return { ...base, kind, text: String(extra.content ?? extra.text ?? "") }
+}
+
 describe("EventStore", () => {
   test("uses the runtime profile for the default data dir", () => {
     process.env.KANNA_RUNTIME_PROFILE = "dev"
@@ -19,4 +42,92 @@ describe("EventStore", () => {
 
     expect(store.dataDir).toEndWith("/.kanna-dev/data")
   })
+
+  test("migrates legacy snapshot and messages log transcripts into per-chat files", async () => {
+    const dataDir = await createTempDataDir()
+    const snapshotPath = join(dataDir, "snapshot.json")
+    const messagesLogPath = join(dataDir, "messages.jsonl")
+    const chatId = "chat-1"
+
+    const snapshot: SnapshotFile = {
+      v: 2,
+      generatedAt: 10,
+      projects: [{
+        id: "project-1",
+        localPath: "/tmp/project",
+        title: "Project",
+        createdAt: 1,
+        updatedAt: 5,
+      }],
+      chats: [{
+        id: chatId,
+        projectId: "project-1",
+        title: "Chat",
+        createdAt: 1,
+        updatedAt: 5,
+        provider: null,
+        planMode: false,
+        sessionToken: null,
+        lastTurnOutcome: null,
+      }],
+      messages: [{
+        chatId,
+        entries: [
+          entry("user_prompt", 100, { content: "hello" }),
+        ],
+      }],
+    }
+
+    await writeFile(snapshotPath, JSON.stringify(snapshot, null, 2), "utf8")
+    await writeFile(messagesLogPath, `${JSON.stringify({
+      v: 2,
+      type: "message_appended",
+      timestamp: 101,
+      chatId,
+      entry: entry("assistant_text", 101, { content: "world" }),
+    })}\n`, "utf8")
+
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    const progress: string[] = []
+    const migrated = await store.migrateLegacyTranscripts((message) => {
+      progress.push(message)
+    })
+
+    expect(migrated).toBe(true)
+    expect(progress.some((message) => message.includes("transcript migration detected"))).toBe(true)
+    expect(progress.at(-1)).toContain("transcript migration complete")
+    expect(store.getMessages(chatId)).toEqual([
+      entry("user_prompt", 100, { content: "hello" }),
+      entry("assistant_text", 101, { text: "world" }),
+    ])
+
+    const migratedSnapshot = JSON.parse(await readFile(snapshotPath, "utf8")) as SnapshotFile
+    expect(migratedSnapshot.messages).toBeUndefined()
+    expect(await readFile(messagesLogPath, "utf8")).toBe("")
+    expect(await readFile(join(dataDir, "transcripts", `${chatId}.jsonl`), "utf8")).toContain('"kind":"assistant_text"')
+  })
+
+  test("appends new transcript entries only to the per-chat transcript file", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    await store.appendMessage(chat.id, entry("user_prompt", 200, { content: "hello" }))
+    await store.appendMessage(chat.id, entry("assistant_text", 201, { content: "world" }))
+    await store.compact()
+
+    expect(store.getMessages(chat.id)).toEqual([
+      entry("user_prompt", 200, { content: "hello" }),
+      entry("assistant_text", 201, { text: "world" }),
+    ])
+    expect(await readFile(join(dataDir, "messages.jsonl"), "utf8")).toBe("")
+
+    const snapshot = JSON.parse(await readFile(join(dataDir, "snapshot.json"), "utf8")) as SnapshotFile
+    expect(snapshot.messages).toBeUndefined()
+    expect(existsSync(join(dataDir, "transcripts", `${chat.id}.jsonl`))).toBe(true)
+  })
 })

package/src/server/event-store.ts

@@ -1,4 +1,5 @@
-import { appendFile, mkdir } from "node:fs/promises"
+import { appendFile, mkdir, rename, writeFile } from "node:fs/promises"
+import { existsSync, readFileSync as readFileSyncImmediate } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
 import { getDataDir, LOG_PREFIX } from "../shared/branding"
@@ -19,6 +20,13 @@ import { resolveLocalPath } from "./paths"
 
 const COMPACTION_THRESHOLD_BYTES = 2 * 1024 * 1024
 
+interface LegacyTranscriptStats {
+  hasLegacyData: boolean
+  sources: Array<"snapshot" | "messages_log">
+  chatCount: number
+  entryCount: number
+}
+
 export class EventStore {
   readonly dataDir: string
   readonly state: StoreState = createEmptyState()
@@ -29,6 +37,10 @@ export class EventStore {
   private readonly chatsLogPath: string
   private readonly messagesLogPath: string
   private readonly turnsLogPath: string
+  private readonly transcriptsDir: string
+  private legacyMessagesByChatId = new Map<string, TranscriptEntry[]>()
+  private snapshotHasLegacyMessages = false
+  private cachedTranscript: { chatId: string; entries: TranscriptEntry[] } | null = null
 
   constructor(dataDir = getDataDir(homedir())) {
     this.dataDir = dataDir
@@ -37,17 +49,19 @@ export class EventStore {
     this.chatsLogPath = path.join(this.dataDir, "chats.jsonl")
     this.messagesLogPath = path.join(this.dataDir, "messages.jsonl")
     this.turnsLogPath = path.join(this.dataDir, "turns.jsonl")
+    this.transcriptsDir = path.join(this.dataDir, "transcripts")
   }
 
   async initialize() {
     await mkdir(this.dataDir, { recursive: true })
+    await mkdir(this.transcriptsDir, { recursive: true })
     await this.ensureFile(this.projectsLogPath)
     await this.ensureFile(this.chatsLogPath)
     await this.ensureFile(this.messagesLogPath)
     await this.ensureFile(this.turnsLogPath)
     await this.loadSnapshot()
     await this.replayLogs()
-    if (await this.shouldCompact()) {
+    if (!(await this.hasLegacyTranscriptData()) && await this.shouldCompact()) {
       await this.compact()
     }
   }
@@ -63,6 +77,7 @@ export class EventStore {
     if (this.storageReset) return
     this.storageReset = true
     this.resetState()
+    this.clearLegacyTranscriptState()
     await Promise.all([
       Bun.write(this.snapshotPath, ""),
       Bun.write(this.projectsLogPath, ""),
@@ -92,8 +107,11 @@ export class EventStore {
       for (const chat of parsed.chats) {
         this.state.chatsById.set(chat.id, { ...chat })
       }
-      for (const messageSet of parsed.messages) {
-        this.state.messagesByChatId.set(messageSet.chatId, cloneTranscriptEntries(messageSet.entries))
+      if (parsed.messages?.length) {
+        this.snapshotHasLegacyMessages = true
+        for (const messageSet of parsed.messages) {
+          this.legacyMessagesByChatId.set(messageSet.chatId, cloneTranscriptEntries(messageSet.entries))
+        }
       }
     } catch (error) {
       console.warn(`${LOG_PREFIX} Failed to load snapshot, resetting local history:`, error)
@@ -105,7 +123,12 @@ export class EventStore {
     this.state.projectsById.clear()
     this.state.projectIdsByPath.clear()
     this.state.chatsById.clear()
-    this.state.messagesByChatId.clear()
+    this.cachedTranscript = null
+  }
+
+  private clearLegacyTranscriptState() {
+    this.legacyMessagesByChatId.clear()
+    this.snapshotHasLegacyMessages = false
   }
 
   private async replayLogs() {
@@ -224,16 +247,10 @@ export class EventStore {
         break
       }
       case "message_appended": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (chat) {
-          if (event.entry.kind === "user_prompt") {
-            chat.lastMessageAt = event.entry.createdAt
-          }
-          chat.updatedAt = Math.max(chat.updatedAt, event.entry.createdAt)
-        }
-        const existing = this.state.messagesByChatId.get(event.chatId) ?? []
+        this.applyMessageMetadata(event.chatId, event.entry)
+        const existing = this.legacyMessagesByChatId.get(event.chatId) ?? []
         existing.push({ ...event.entry })
-        this.state.messagesByChatId.set(event.chatId, existing)
+        this.legacyMessagesByChatId.set(event.chatId, existing)
         break
       }
       case "turn_started": {
@@ -273,6 +290,15 @@ export class EventStore {
     }
   }
 
+  private applyMessageMetadata(chatId: string, entry: TranscriptEntry) {
+    const chat = this.state.chatsById.get(chatId)
+    if (!chat) return
+    if (entry.kind === "user_prompt") {
+      chat.lastMessageAt = entry.createdAt
+    }
+    chat.updatedAt = Math.max(chat.updatedAt, entry.createdAt)
+  }
+
   private append<TEvent extends StoreEvent>(filePath: string, event: TEvent) {
     const payload = `${JSON.stringify(event)}\n`
     this.writeChain = this.writeChain.then(async () => {
@@ -282,6 +308,28 @@ export class EventStore {
     return this.writeChain
   }
 
+  private transcriptPath(chatId: string) {
+    return path.join(this.transcriptsDir, `${chatId}.jsonl`)
+  }
+
+  private loadTranscriptFromDisk(chatId: string) {
+    const transcriptPath = this.transcriptPath(chatId)
+    if (!existsSync(transcriptPath)) {
+      return []
+    }
+
+    const text = readFileSyncImmediate(transcriptPath, "utf8")
+    if (!text.trim()) return []
+
+    const entries: TranscriptEntry[] = []
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.trim()
+      if (!line) continue
+      entries.push(JSON.parse(line) as TranscriptEntry)
+    }
+    return entries
+  }
+
   async openProject(localPath: string, title?: string) {
     const normalized = resolveLocalPath(localPath)
     const existingId = this.state.projectIdsByPath.get(normalized)
@@ -392,14 +440,17 @@ export class EventStore {
 
   async appendMessage(chatId: string, entry: TranscriptEntry) {
     this.requireChat(chatId)
-    const event: MessageEvent = {
-      v: STORE_VERSION,
-      type: "message_appended",
-      timestamp: Date.now(),
-      chatId,
-      entry,
-    }
-    await this.append(this.messagesLogPath, event)
+    const payload = `${JSON.stringify(entry)}\n`
+    const transcriptPath = this.transcriptPath(chatId)
+    this.writeChain = this.writeChain.then(async () => {
+      await mkdir(this.transcriptsDir, { recursive: true })
+      await appendFile(transcriptPath, payload, "utf8")
+      this.applyMessageMetadata(chatId, entry)
+      if (this.cachedTranscript?.chatId === chatId) {
+        this.cachedTranscript.entries.push({ ...entry })
+      }
+    })
+    return this.writeChain
   }
 
   async recordTurnStarted(chatId: string) {
@@ -481,7 +532,19 @@ export class EventStore {
   }
 
   getMessages(chatId: string) {
-    return cloneTranscriptEntries(this.state.messagesByChatId.get(chatId) ?? [])
+    if (this.cachedTranscript?.chatId === chatId) {
+      return cloneTranscriptEntries(this.cachedTranscript.entries)
+    }
+
+    const legacyEntries = this.legacyMessagesByChatId.get(chatId)
+    if (legacyEntries) {
+      this.cachedTranscript = { chatId, entries: cloneTranscriptEntries(legacyEntries) }
+      return cloneTranscriptEntries(this.cachedTranscript.entries)
+    }
+
+    const entries = this.loadTranscriptFromDisk(chatId)
+    this.cachedTranscript = { chatId, entries }
+    return cloneTranscriptEntries(entries)
   }
 
   listProjects() {
@@ -498,20 +561,46 @@ export class EventStore {
     return this.listChatsByProject(projectId).length
   }
 
-  async compact() {
-    const snapshot: SnapshotFile = {
+  async getLegacyTranscriptStats(): Promise<LegacyTranscriptStats> {
+    const messagesLogSize = await Bun.file(this.messagesLogPath).size
+    const sources: LegacyTranscriptStats["sources"] = []
+    if (this.snapshotHasLegacyMessages) {
+      sources.push("snapshot")
+    }
+    if (messagesLogSize > 0) {
+      sources.push("messages_log")
+    }
+
+    let entryCount = 0
+    for (const entries of this.legacyMessagesByChatId.values()) {
+      entryCount += entries.length
+    }
+
+    return {
+      hasLegacyData: sources.length > 0 || this.legacyMessagesByChatId.size > 0,
+      sources,
+      chatCount: this.legacyMessagesByChatId.size,
+      entryCount,
+    }
+  }
+
+  async hasLegacyTranscriptData() {
+    return (await this.getLegacyTranscriptStats()).hasLegacyData
+  }
+
+  private createSnapshot(): SnapshotFile {
+    return {
       v: STORE_VERSION,
       generatedAt: Date.now(),
       projects: this.listProjects().map((project) => ({ ...project })),
       chats: [...this.state.chatsById.values()]
         .filter((chat) => !chat.deletedAt)
         .map((chat) => ({ ...chat })),
-      messages: [...this.state.messagesByChatId.entries()].map(([chatId, entries]) => ({
-        chatId,
-        entries: cloneTranscriptEntries(entries),
-      })),
     }
+  }
 
+  async compact() {
+    const snapshot = this.createSnapshot()
     await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
     await Promise.all([
       Bun.write(this.projectsLogPath, ""),
@@ -521,6 +610,37 @@ export class EventStore {
     ])
   }
 
+  async migrateLegacyTranscripts(onProgress?: (message: string) => void) {
+    const stats = await this.getLegacyTranscriptStats()
+    if (!stats.hasLegacyData) return false
+
+    const sourceSummary = stats.sources.map((source) => source === "messages_log" ? "messages.jsonl" : "snapshot.json").join(", ")
+    onProgress?.(`${LOG_PREFIX} transcript migration detected: ${stats.chatCount} chats, ${stats.entryCount} entries from ${sourceSummary}`)
+
+    const messageSets = [...this.legacyMessagesByChatId.entries()]
+    onProgress?.(`${LOG_PREFIX} transcript migration: writing ${messageSets.length} per-chat transcript files`)
+
+    await mkdir(this.transcriptsDir, { recursive: true })
+    const logEveryChat = messageSets.length <= 10
+    for (let index = 0; index < messageSets.length; index += 1) {
+      const [chatId, entries] = messageSets[index]
+      const transcriptPath = this.transcriptPath(chatId)
+      const tempPath = `${transcriptPath}.tmp`
+      const payload = entries.map((entry) => JSON.stringify(entry)).join("\n")
+      await writeFile(tempPath, payload ? `${payload}\n` : "", "utf8")
+      await rename(tempPath, transcriptPath)
+      if (logEveryChat || (index + 1) % 25 === 0 || index === messageSets.length - 1) {
+        onProgress?.(`${LOG_PREFIX} transcript migration: ${index + 1}/${messageSets.length} chats`)
+      }
+    }
+
+    this.clearLegacyTranscriptState()
+    await this.compact()
+    this.cachedTranscript = null
+    onProgress?.(`${LOG_PREFIX} transcript migration complete`)
+    return true
+  }
+
   private async shouldCompact() {
     const sizes = await Promise.all([
       Bun.file(this.projectsLogPath).size,

package/src/server/events.ts

@@ -22,7 +22,6 @@ export interface StoreState {
   projectsById: Map<string, ProjectRecord>
   projectIdsByPath: Map<string, string>
   chatsById: Map<string, ChatRecord>
-  messagesByChatId: Map<string, TranscriptEntry[]>
 }
 
 export interface SnapshotFile {
@@ -30,7 +29,7 @@ export interface SnapshotFile {
   generatedAt: number
   projects: ProjectRecord[]
   chats: ChatRecord[]
-  messages: Array<{ chatId: string; entries: TranscriptEntry[] }>
+  messages?: Array<{ chatId: string; entries: TranscriptEntry[] }>
 }
 
 export type ProjectEvent = {
@@ -133,7 +132,6 @@ export function createEmptyState(): StoreState {
     projectsById: new Map(),
     projectIdsByPath: new Map(),
     chatsById: new Map(),
-    messagesByChatId: new Map(),
   }
 }
 

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

@@ -4,11 +4,34 @@ import {
   normalizeClaudeModelOptions,
   normalizeCodexModelOptions,
 } from "./provider-catalog"
+import { resolveClaudeApiModelId } from "../shared/types"
 
 describe("provider catalog normalization", () => {
   test("maps legacy Claude effort into shared model options", () => {
-    expect(normalizeClaudeModelOptions(undefined, "max")).toEqual({
+    expect(normalizeClaudeModelOptions("opus", undefined, "max")).toEqual({
       reasoningEffort: "max",
+      contextWindow: "200k",
+    })
+  })
+
+  test("normalizes Claude context window only for supported models", () => {
+    expect(normalizeClaudeModelOptions("sonnet", {
+      claude: {
+        reasoningEffort: "medium",
+        contextWindow: "1m",
+      },
+    })).toEqual({
+      reasoningEffort: "medium",
+      contextWindow: "1m",
+    })
+
+    expect(normalizeClaudeModelOptions("haiku", {
+      claude: {
+        reasoningEffort: "medium",
+        contextWindow: "1m",
+      },
+    })).toMatchObject({
+      reasoningEffort: "medium",
     })
   })
 
@@ -31,4 +54,9 @@ describe("provider catalog normalization", () => {
     })
     expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
   })
+
+  test("resolves Claude API model ids for 1m context window", () => {
+    expect(resolveClaudeApiModelId("opus", "1m")).toBe("opus[1m]")
+    expect(resolveClaudeApiModelId("sonnet", "200k")).toBe("sonnet")
+  })
 })

package/src/server/provider-catalog.ts

@@ -2,6 +2,7 @@ import type {
   AgentProvider,
   ClaudeModelOptions,
   CodexModelOptions,
+  ClaudeContextWindow,
   ModelOptions,
   ProviderCatalogEntry,
   ProviderModelOption,
@@ -11,6 +12,7 @@ import {
   DEFAULT_CLAUDE_MODEL_OPTIONS,
   DEFAULT_CODEX_MODEL_OPTIONS,
   PROVIDERS,
+  normalizeClaudeContextWindow,
   isClaudeReasoningEffort,
   isCodexReasoningEffort,
 } from "../shared/types"
@@ -47,7 +49,11 @@ export function normalizeServerModel(provider: AgentProvider, model?: string): s
   return catalog.defaultModel
 }
 
-export function normalizeClaudeModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): ClaudeModelOptions {
+export function normalizeClaudeModelOptions(
+  model: string,
+  modelOptions?: ModelOptions,
+  legacyEffort?: string
+): ClaudeModelOptions {
   const reasoningEffort = modelOptions?.claude?.reasoningEffort
   return {
     reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
@@ -55,6 +61,7 @@ export function normalizeClaudeModelOptions(modelOptions?: ModelOptions, legacyE
       : isClaudeReasoningEffort(legacyEffort)
         ? legacyEffort
         : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
+    contextWindow: normalizeClaudeContextWindow(model, modelOptions?.claude?.contextWindow as ClaudeContextWindow | undefined),
   }
 }
 

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

@@ -51,7 +51,7 @@ describe("read models", () => {
       lastTurnOutcome: null,
     })
 
-    const chat = deriveChatSnapshot(state, new Map(), "chat-1")
+    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([

package/src/server/read-models.ts

@@ -8,7 +8,6 @@ import type {
   SidebarProjectGroup,
 } from "../shared/types"
 import type { ChatRecord, StoreState } from "./events"
-import { cloneTranscriptEntries } from "./events"
 import { resolveLocalPath } from "./paths"
 import { SERVER_PROVIDERS } from "./provider-catalog"
 
@@ -98,7 +97,8 @@ export function deriveLocalProjectsSnapshot(
 export function deriveChatSnapshot(
   state: StoreState,
   activeStatuses: Map<string, KannaStatus>,
-  chatId: string
+  chatId: string,
+  getMessages: (chatId: string) => ChatSnapshot["messages"]
 ): ChatSnapshot | null {
   const chat = state.chatsById.get(chatId)
   if (!chat || chat.deletedAt) return null
@@ -118,7 +118,7 @@ export function deriveChatSnapshot(
 
   return {
     runtime,
-    messages: cloneTranscriptEntries(state.messagesByChatId.get(chat.id) ?? []),
+    messages: getMessages(chat.id),
     availableProviders: [...SERVER_PROVIDERS],
   }
 }

package/src/server/server.ts

@@ -14,6 +14,7 @@ export interface StartKannaServerOptions {
   port?: number
   host?: string
   strictPort?: boolean
+  onMigrationProgress?: (message: string) => void
   update?: {
     version: string
     fetchLatestVersion: (packageName: string) => Promise<string>
@@ -28,6 +29,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const store = new EventStore()
   const machineDisplayName = getMachineDisplayName()
   await store.initialize()
+  await store.migrateLegacyTranscripts(options.onMigrationProgress)
   let discoveredProjects: DiscoveredProject[] = []
 
   async function refreshDiscovery() {

package/src/server/share.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test"
+import { ensureCloudflaredInstalled, logShareDetails, startShareTunnel } from "./share"
+
+describe("ensureCloudflaredInstalled", () => {
+  test("returns immediately when the binary already exists", async () => {
+    const installCalls: string[] = []
+
+    const result = await ensureCloudflaredInstalled({
+      cloudflaredBin: "/tmp/cloudflared",
+      existsSync: () => true,
+      installCloudflared: async (to) => {
+        installCalls.push(to)
+        return to
+      },
+    })
+
+    expect(result).toBe("/tmp/cloudflared")
+    expect(installCalls).toEqual([])
+  })
+
+  test("installs the binary on demand when it is missing", async () => {
+    const installCalls: string[] = []
+    const logLines: string[] = []
+
+    const result = await ensureCloudflaredInstalled({
+      cloudflaredBin: "/tmp/cloudflared",
+      existsSync: () => false,
+      installCloudflared: async (to) => {
+        installCalls.push(to)
+        return to
+      },
+      log: (message) => {
+        logLines.push(message)
+      },
+    })
+
+    expect(result).toBe("/tmp/cloudflared")
+    expect(installCalls).toEqual(["/tmp/cloudflared"])
+    expect(logLines).toEqual(["installing cloudflared binary"])
+  })
+})
+
+describe("startShareTunnel", () => {
+  test("starts a quick tunnel after ensuring the binary exists", async () => {
+    const installCalls: string[] = []
+    const quickTunnelUrls: string[] = []
+    let stopCalls = 0
+
+    const shareTunnel = await startShareTunnel("http://localhost:3333", {
+      cloudflaredBin: "/tmp/cloudflared",
+      existsSync: () => false,
+      installCloudflared: async (to) => {
+        installCalls.push(to)
+        return to
+      },
+      createQuickTunnel: (localUrl) => {
+        quickTunnelUrls.push(localUrl)
+        return {
+          once(event, listener) {
+            if (event === "url") {
+              queueMicrotask(() => (listener as (url: string) => void)("https://kanna.trycloudflare.com"))
+            }
+            return this
+          },
+          off(_event, _listener) {
+            return this
+          },
+          stop() {
+            stopCalls += 1
+            return true
+          },
+        }
+      },
+    })
+
+    expect(installCalls).toEqual(["/tmp/cloudflared"])
+    expect(quickTunnelUrls).toEqual(["http://localhost:3333"])
+    expect(shareTunnel.publicUrl).toBe("https://kanna.trycloudflare.com")
+    shareTunnel.stop()
+    expect(stopCalls).toBe(1)
+  })
+})
+
+describe("logShareDetails", () => {
+  test("prints qr, public url, and local url in the expected order", async () => {
+    const logLines: string[] = []
+
+    await logShareDetails(
+      (message) => {
+        logLines.push(message)
+      },
+      "https://kanna.trycloudflare.com",
+      "http://localhost:3333",
+      async (url) => `[qr:${url}]\n`,
+    )
+
+    expect(logLines).toEqual([
+      "QR Code:",
+      "[qr:https://kanna.trycloudflare.com]",
+      "",
+      "Public URL:",
+      "https://kanna.trycloudflare.com",
+      "",
+      "Local URL:",
+      "http://localhost:3333",
+    ])
+  })
+})