kanna-code 0.15.0 → 0.17.0

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/server/ws-router.ts

@@ -121,7 +121,7 @@ export function createWsRouter({
       id,
       snapshot: {
         type: "chat",
-        data: deriveChatSnapshot(store.state, agent.getActiveStatuses(), topic.chatId),
+        data: deriveChatSnapshot(store.state, agent.getActiveStatuses(), topic.chatId, (chatId) => store.getMessages(chatId)),
       },
     }
   }

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

@@ -7,6 +7,7 @@ export interface ProviderModelOption {
   id: string
   label: string
   supportsEffort: boolean
+  contextWindowOptions?: readonly ProviderContextWindowOption[]
 }
 
 export interface ProviderEffortOption {
@@ -14,6 +15,11 @@ export interface ProviderEffortOption {
   label: string
 }
 
+export interface ProviderContextWindowOption {
+  id: ClaudeContextWindow
+  label: string
+}
+
 export const CLAUDE_REASONING_OPTIONS = [
   { id: "low", label: "Low" },
   { id: "medium", label: "Medium" },
@@ -31,10 +37,12 @@ export const CODEX_REASONING_OPTIONS = [
 
 export type ClaudeReasoningEffort = (typeof CLAUDE_REASONING_OPTIONS)[number]["id"]
 export type CodexReasoningEffort = (typeof CODEX_REASONING_OPTIONS)[number]["id"]
+export type ClaudeContextWindow = "200k" | "1m"
 export type ServiceTier = "fast"
 
 export interface ClaudeModelOptions {
   reasoningEffort: ClaudeReasoningEffort
+  contextWindow: ClaudeContextWindow
 }
 
 export interface CodexModelOptions {
@@ -53,6 +61,7 @@ export type ModelOptions = Partial<{
 
 export const DEFAULT_CLAUDE_MODEL_OPTIONS = {
   reasoningEffort: "high",
+  contextWindow: "200k",
 } as const satisfies ClaudeModelOptions
 
 export const DEFAULT_CODEX_MODEL_OPTIONS = {
@@ -68,6 +77,15 @@ export function isCodexReasoningEffort(value: unknown): value is CodexReasoningE
   return CODEX_REASONING_OPTIONS.some((option) => option.id === value)
 }
 
+export const CLAUDE_CONTEXT_WINDOW_OPTIONS = [
+  { id: "200k", label: "200k" },
+  { id: "1m", label: "1M" },
+] as const satisfies readonly ProviderContextWindowOption[]
+
+export function isClaudeContextWindow(value: unknown): value is ClaudeContextWindow {
+  return CLAUDE_CONTEXT_WINDOW_OPTIONS.some((option) => option.id === value)
+}
+
 export interface ProviderCatalogEntry {
   id: AgentProvider
   label: string
@@ -86,8 +104,8 @@ export const PROVIDERS: ProviderCatalogEntry[] = [
     defaultEffort: "high",
     supportsPlanMode: true,
     models: [
-      { id: "opus", label: "Opus", supportsEffort: true },
-      { id: "sonnet", label: "Sonnet", supportsEffort: true },
+      { id: "opus", label: "Opus", supportsEffort: true, contextWindowOptions: [...CLAUDE_CONTEXT_WINDOW_OPTIONS] },
+      { id: "sonnet", label: "Sonnet", supportsEffort: true, contextWindowOptions: [...CLAUDE_CONTEXT_WINDOW_OPTIONS] },
       { id: "haiku", label: "Haiku", supportsEffort: true },
     ],
     efforts: [...CLAUDE_REASONING_OPTIONS],
@@ -114,6 +132,26 @@ export function getProviderCatalog(provider: AgentProvider): ProviderCatalogEntr
   return entry
 }
 
+export function getClaudeModelOption(modelId: string): ProviderModelOption | undefined {
+  return getProviderCatalog("claude").models.find((candidate) => candidate.id === modelId)
+}
+
+export function getClaudeContextWindowOptions(modelId: string): readonly ProviderContextWindowOption[] {
+  return getClaudeModelOption(modelId)?.contextWindowOptions ?? []
+}
+
+export function normalizeClaudeContextWindow(modelId: string, contextWindow?: unknown): ClaudeContextWindow {
+  const options = getClaudeContextWindowOptions(modelId)
+  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
+}
+
+export function resolveClaudeApiModelId(modelId: string, contextWindow?: ClaudeContextWindow): string {
+  return contextWindow === "1m" ? `${modelId}[1m]` : modelId
+}
+
 export type KannaStatus =
   | "idle"
   | "starting"