kanna-code 0.16.0 → 0.17.0

package/src/server/event-store.ts

@@ -1,4 +1,4 @@
-import { appendFile, mkdir, readFile, rename, writeFile } 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"
@@ -588,8 +588,8 @@ export class EventStore {
     return (await this.getLegacyTranscriptStats()).hasLegacyData
   }
 
-  private createSnapshot(includeLegacyMessages: boolean): SnapshotFile {
-    const snapshot: SnapshotFile = {
+  private createSnapshot(): SnapshotFile {
+    return {
       v: STORE_VERSION,
       generatedAt: Date.now(),
       projects: this.listProjects().map((project) => ({ ...project })),
@@ -597,30 +597,10 @@ export class EventStore {
         .filter((chat) => !chat.deletedAt)
         .map((chat) => ({ ...chat })),
     }
-
-    if (includeLegacyMessages) {
-      snapshot.messages = [...this.legacyMessagesByChatId.entries()].map(([chatId, entries]) => ({
-        chatId,
-        entries: cloneTranscriptEntries(entries),
-      }))
-    }
-
-    return snapshot
   }
 
   async compact() {
-    const snapshot = this.createSnapshot(false)
-    await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
-    await Promise.all([
-      Bun.write(this.projectsLogPath, ""),
-      Bun.write(this.chatsLogPath, ""),
-      Bun.write(this.messagesLogPath, ""),
-      Bun.write(this.turnsLogPath, ""),
-    ])
-  }
-
-  private async compactLegacyMessagesIntoSnapshot() {
-    const snapshot = this.createSnapshot(true)
+    const snapshot = this.createSnapshot()
     await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
     await Promise.all([
       Bun.write(this.projectsLogPath, ""),
@@ -636,17 +616,14 @@ export class EventStore {
 
     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}`)
-    onProgress?.(`${LOG_PREFIX} transcript migration: compacting legacy transcript state into snapshot`)
-    await this.compactLegacyMessagesIntoSnapshot()
 
-    const snapshot = JSON.parse(await readFile(this.snapshotPath, "utf8")) as SnapshotFile
-    const messageSets = snapshot.messages ?? []
+    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 [chatId, entries] = messageSets[index]
       const transcriptPath = this.transcriptPath(chatId)
       const tempPath = `${transcriptPath}.tmp`
       const payload = entries.map((entry) => JSON.stringify(entry)).join("\n")
@@ -657,9 +634,8 @@ export class EventStore {
       }
     }
 
-    delete snapshot.messages
-    await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
     this.clearLegacyTranscriptState()
+    await this.compact()
     this.cachedTranscript = null
     onProgress?.(`${LOG_PREFIX} transcript migration complete`)
     return true

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

@@ -30,7 +30,7 @@ describe("provider catalog normalization", () => {
         reasoningEffort: "medium",
         contextWindow: "1m",
       },
-    })).toEqual({
+    })).toMatchObject({
       reasoningEffort: "medium",
     })
   })

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",
+    ])
+  })
+})

package/src/server/share.ts

@@ -0,0 +1,113 @@
+import { existsSync } from "node:fs"
+import QRCode from "qrcode"
+import { Tunnel, bin as cloudflaredBin, install as installCloudflared } from "cloudflared"
+
+export interface StartedShareTunnel {
+  publicUrl: string
+  stop: () => void
+}
+
+export interface ShareTunnelProcess {
+  once(event: "url", listener: (url: string) => void): ShareTunnelProcess
+  once(event: "error", listener: (error: Error) => void): ShareTunnelProcess
+  once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): ShareTunnelProcess
+  off(event: "url", listener: (url: string) => void): ShareTunnelProcess
+  off(event: "error", listener: (error: Error) => void): ShareTunnelProcess
+  off(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): ShareTunnelProcess
+  stop(): boolean
+}
+
+export interface ShareTunnelDeps {
+  cloudflaredBin?: string
+  existsSync?: (path: string) => boolean
+  installCloudflared?: (to: string) => Promise<string>
+  createQuickTunnel?: (localUrl: string) => ShareTunnelProcess
+  log?: (message: string) => void
+}
+
+export async function renderTerminalQr(url: string) {
+  return QRCode.toString(url, {
+    type: "terminal",
+    small: true,
+    errorCorrectionLevel: "M",
+  })
+}
+
+export async function ensureCloudflaredInstalled(
+  deps: ShareTunnelDeps = {},
+) {
+  const resolvedBin = deps.cloudflaredBin ?? cloudflaredBin
+  const fileExists = deps.existsSync ?? existsSync
+  const installBinary = deps.installCloudflared ?? installCloudflared
+
+  if (fileExists(resolvedBin)) {
+    return resolvedBin
+  }
+
+  deps.log?.("installing cloudflared binary")
+  await installBinary(resolvedBin)
+  return resolvedBin
+}
+
+export async function startShareTunnel(localUrl: string, deps: ShareTunnelDeps = {}): Promise<StartedShareTunnel> {
+  await ensureCloudflaredInstalled(deps)
+  const tunnel = (deps.createQuickTunnel ?? ((url) => Tunnel.quick(url)))(localUrl)
+
+  const publicUrl = 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(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)
+  })
+
+  return {
+    publicUrl,
+    stop: () => {
+      tunnel.stop()
+    },
+  }
+}
+
+export async function logShareDetails(
+  log: (message: string) => void,
+  publicUrl: string,
+  localUrl: string,
+  renderShareQrImpl: (url: string) => Promise<string> = renderTerminalQr,
+) {
+  const qrCode = await renderShareQrImpl(publicUrl)
+
+  log("QR Code:")
+  log(qrCode.trimEnd())
+  log("")
+  log("Public URL:")
+  log(publicUrl)
+  log("")
+  log("Local URL:")
+  log(localUrl)
+}

package/src/shared/dev-ports.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import {
   DEFAULT_DEV_CLIENT_PORT,
   getDefaultDevServerPort,
+  parseDevArgs,
   resolveDevPorts,
   stripPortArg,
 } from "./dev-ports"
@@ -50,3 +51,34 @@ describe("stripPortArg", () => {
     ])
   })
 })
+
+describe("parseDevArgs", () => {
+  test("derives dev share options from the client port", () => {
+    expect(parseDevArgs(["--share", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: true,
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: [],
+    })
+  })
+
+  test("rejects combining --share with --host or --remote", () => {
+    expect(() => parseDevArgs(["--share", "--host", "dev-box"], "dev-machine")).toThrow("--share cannot be used with --host")
+    expect(() => parseDevArgs(["--host", "dev-box", "--share"], "dev-machine")).toThrow("--share cannot be used with --host")
+    expect(() => parseDevArgs(["--share", "--remote"], "dev-machine")).toThrow("--share cannot be used with --remote")
+    expect(() => parseDevArgs(["--remote", "--share"], "dev-machine")).toThrow("--share cannot be used with --remote")
+  })
+
+  test("preserves existing remote host behavior when share is off", () => {
+    expect(parseDevArgs(["--remote", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: false,
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: ["--remote"],
+    })
+  })
+})

package/src/shared/dev-ports.ts

@@ -4,6 +4,15 @@ export function getDefaultDevServerPort(clientPort = DEFAULT_DEV_CLIENT_PORT) {
   return clientPort + 1
 }
 
+export interface DevArgResolution {
+  clientPort: number
+  serverPort: number
+  share: boolean
+  backendTargetHost: string
+  allowedHosts: true | string[]
+  serverArgs: string[]
+}
+
 export function resolveDevPorts(args: string[]) {
   let clientPort = DEFAULT_DEV_CLIENT_PORT
 
@@ -41,3 +50,49 @@ export function stripPortArg(args: string[]) {
 
   return stripped
 }
+
+export function parseDevArgs(args: string[], localHostname: string): DevArgResolution {
+  const { clientPort, serverPort } = resolveDevPorts(args)
+  const serverArgs = stripPortArg(args).filter((arg) => arg !== "--share")
+  let share = false
+  let sawHost = false
+  let sawRemote = false
+  let backendTargetHost = "127.0.0.1"
+  let allowAllHosts = false
+  const hosts = new Set<string>(["localhost", "127.0.0.1", "0.0.0.0", localHostname])
+
+  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")
+      share = true
+      continue
+    }
+    if (arg === "--remote") {
+      if (share) throw new Error("--share cannot be used with --remote")
+      sawRemote = true
+      backendTargetHost = "127.0.0.1"
+      allowAllHosts = true
+      continue
+    }
+    if (arg !== "--host") continue
+
+    const next = args[index + 1]
+    if (!next || next.startsWith("-")) continue
+    if (share) throw new Error("--share cannot be used with --host")
+    sawHost = true
+    hosts.add(next)
+    backendTargetHost = next === "0.0.0.0" ? "127.0.0.1" : next
+    index += 1
+  }
+
+  return {
+    clientPort,
+    serverPort,
+    share,
+    backendTargetHost,
+    allowedHosts: share || allowAllHosts ? true : [...hosts],
+    serverArgs,
+  }
+}

package/src/shared/types.ts

@@ -42,7 +42,7 @@ export type ServiceTier = "fast"
 
 export interface ClaudeModelOptions {
   reasoningEffort: ClaudeReasoningEffort
-  contextWindow?: ClaudeContextWindow
+  contextWindow: ClaudeContextWindow
 }
 
 export interface CodexModelOptions {
@@ -140,9 +140,9 @@ export function getClaudeContextWindowOptions(modelId: string): readonly Provide
   return getClaudeModelOption(modelId)?.contextWindowOptions ?? []
 }
 
-export function normalizeClaudeContextWindow(modelId: string, contextWindow?: unknown): ClaudeContextWindow | undefined {
+export function normalizeClaudeContextWindow(modelId: string, contextWindow?: unknown): ClaudeContextWindow {
   const options = getClaudeContextWindowOptions(modelId)
-  if (options.length === 0) return undefined
+  if (options.length === 0) return DEFAULT_CLAUDE_MODEL_OPTIONS.contextWindow
   return options.some((option) => option.id === contextWindow)
     ? contextWindow as ClaudeContextWindow
     : DEFAULT_CLAUDE_MODEL_OPTIONS.contextWindow