kanna-code 0.34.5 → 0.35.0

package/src/server/standalone-export.ts

@@ -0,0 +1,402 @@
+import { randomBytes } from "node:crypto"
+import type { Dirent } from "node:fs"
+import path from "node:path"
+import { cp as copyPath, copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises"
+import type {
+  StandaloneTranscriptAttachmentMode,
+  StandaloneTranscriptBundle,
+  StandaloneTranscriptExportResult,
+  StandaloneTranscriptTheme,
+  TranscriptEntry,
+} from "../shared/types"
+import { APP_VERSION } from "../shared/branding"
+import { getProjectExportDir } from "./paths"
+
+const STANDALONE_TRANSCRIPT_BUNDLE_VERSION = 1 as const
+const STANDALONE_SHARE_UPLOAD_BASE_URL = "https://kanna.sh/api/share"
+const STANDALONE_SHARE_PUBLIC_BASE_URL = "https://share.kanna.sh"
+const STANDALONE_SHARE_WORKSPACE_PATH = "/workspace"
+const STANDALONE_SHARE_ASSET_CACHE_CONTROL = "public, max-age=31536000, immutable"
+const CONTENT_TYPES_BY_EXTENSION: Record<string, string> = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".manifest": "application/manifest+json; charset=utf-8",
+  ".mp3": "audio/mpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8",
+  ".webp": "image/webp",
+  ".woff2": "font/woff2",
+}
+
+export interface WriteStandaloneTranscriptExportArgs {
+  chatId: string
+  title: string
+  localPath: string
+  theme: StandaloneTranscriptTheme
+  attachmentMode: StandaloneTranscriptAttachmentMode
+  messages: TranscriptEntry[]
+}
+
+export interface StandaloneExportDeps {
+  viewerDistDir?: string
+  now?: Date
+  mkdir?: typeof mkdir
+  writeFile?: typeof writeFile
+  readFile?: typeof readFile
+  copyDirectory?: (sourceDir: string, targetDir: string) => Promise<void>
+  copyFile?: typeof copyFile
+  readDir?: (targetPath: string) => Promise<Dirent[]>
+  pathExists?: (targetPath: string) => Promise<boolean>
+  fetch?: FetchLike
+  shareUploadBaseUrl?: string
+  sharePublicBaseUrl?: string
+  shareSlugSuffix?: string
+}
+
+interface PreparedMessagesResult {
+  messages: TranscriptEntry[]
+  totalAttachmentCount: number
+  bundledAttachmentCount: number
+}
+
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>
+
+export function getStandaloneViewerDistDir() {
+  return path.join(import.meta.dir, "..", "..", "dist", "export-viewer")
+}
+
+export async function writeStandaloneTranscriptExport(
+  args: WriteStandaloneTranscriptExportArgs,
+  deps: StandaloneExportDeps = {},
+): Promise<StandaloneTranscriptExportResult> {
+  const viewerDistDir = deps.viewerDistDir ?? getStandaloneViewerDistDir()
+  const ensureDir = deps.mkdir ?? mkdir
+  const writeFileImpl = deps.writeFile ?? writeFile
+  const readFileImpl = deps.readFile ?? readFile
+  const copyDirectory = deps.copyDirectory ?? (async (sourceDir, targetDir) => {
+    await copyPath(sourceDir, targetDir, { recursive: true })
+  })
+  const copyFileImpl = deps.copyFile ?? copyFile
+  const readDir = deps.readDir ?? defaultReadDir
+  const pathExists = deps.pathExists ?? defaultPathExists
+  const fetchImpl = deps.fetch ?? fetch
+  const now = deps.now ?? new Date()
+  const shareUploadBaseUrl = deps.shareUploadBaseUrl ?? STANDALONE_SHARE_UPLOAD_BASE_URL
+  const sharePublicBaseUrl = deps.sharePublicBaseUrl ?? STANDALONE_SHARE_PUBLIC_BASE_URL
+
+  if (!(await pathExists(viewerDistDir))) {
+    throw new Error("Standalone viewer bundle not found. Run `bun run build`.")
+  }
+
+  const exportRootDir = getProjectExportDir(args.localPath)
+  await ensureDir(exportRootDir, { recursive: true })
+
+  const outputDir = await resolveUniqueExportDir(exportRootDir, args.title || args.chatId, now, pathExists)
+  await copyDirectory(viewerDistDir, outputDir)
+
+  const attachmentsDir = path.join(outputDir, "attachments")
+  const prepared = await prepareStandaloneMessages(args.messages, {
+    attachmentMode: args.attachmentMode,
+    localPath: args.localPath,
+    attachmentsDir,
+    copyFile: copyFileImpl,
+    mkdir: ensureDir,
+    pathExists,
+  })
+
+  const bundle: StandaloneTranscriptBundle = {
+    version: STANDALONE_TRANSCRIPT_BUNDLE_VERSION,
+    chatId: args.chatId,
+    title: args.title,
+    localPath: STANDALONE_SHARE_WORKSPACE_PATH,
+    exportedAt: now.toISOString(),
+    viewerVersion: APP_VERSION,
+    theme: args.theme,
+    attachmentMode: args.attachmentMode,
+    messages: prepared.messages,
+  }
+
+  const transcriptJsonPath = path.join(outputDir, "transcript.json")
+  await writeFileImpl(transcriptJsonPath, `${JSON.stringify(bundle, null, 2)}\n`, "utf8")
+  const shareSlug = buildStandaloneShareSlug(args.title || args.chatId, deps.shareSlugSuffix)
+  const shareUrl = buildStandaloneShareUrl(sharePublicBaseUrl, shareSlug)
+  const uploadedFileCount = await uploadStandaloneExportDirectory({
+    outputDir,
+    shareSlug,
+    uploadBaseUrl: shareUploadBaseUrl,
+    fetch: fetchImpl,
+    pathExists,
+    readDir,
+    readFile: readFileImpl,
+  })
+
+  return {
+    outputDir,
+    indexHtmlPath: path.join(outputDir, "index.html"),
+    transcriptJsonPath,
+    attachmentMode: args.attachmentMode,
+    totalAttachmentCount: prepared.totalAttachmentCount,
+    bundledAttachmentCount: prepared.bundledAttachmentCount,
+    shareSlug,
+    shareUrl,
+    uploadedFileCount,
+  }
+}
+
+async function prepareStandaloneMessages(
+  messages: TranscriptEntry[],
+  args: {
+    attachmentMode: StandaloneTranscriptAttachmentMode
+    localPath: string
+    attachmentsDir: string
+    copyFile: typeof copyFile
+    mkdir: typeof mkdir
+    pathExists: (targetPath: string) => Promise<boolean>
+  },
+): Promise<PreparedMessagesResult> {
+  const preparedMessages = structuredClone(messages)
+  let totalAttachmentCount = 0
+  let bundledAttachmentCount = 0
+  let attachmentsDirCreated = false
+
+  for (const message of preparedMessages) {
+    if (message.kind !== "user_prompt" || !message.attachments?.length) {
+      continue
+    }
+
+    totalAttachmentCount += message.attachments.length
+
+    for (const attachment of message.attachments) {
+      if (args.attachmentMode === "metadata") {
+        rewriteAttachmentAsMetadata(attachment)
+        continue
+      }
+
+      if (!attachment.absolutePath || !(await args.pathExists(attachment.absolutePath))) {
+        rewriteAttachmentAsMetadata(attachment)
+        continue
+      }
+
+      if (!attachmentsDirCreated) {
+        await args.mkdir(args.attachmentsDir, { recursive: true })
+        attachmentsDirCreated = true
+      }
+
+      const exportedFileName = `${sanitizeFileNameSegment(attachment.id)}-${sanitizeFileNameSegment(path.basename(attachment.displayName || attachment.absolutePath))}`
+      const destinationPath = path.join(args.attachmentsDir, exportedFileName)
+      await args.copyFile(attachment.absolutePath, destinationPath)
+      bundledAttachmentCount += 1
+
+      const relativeDestinationPath = `./attachments/${exportedFileName}`
+      attachment.absolutePath = relativeDestinationPath
+      attachment.relativePath = relativeDestinationPath
+      attachment.contentUrl = relativeDestinationPath
+    }
+  }
+
+  rewriteLocalPathsForShare(preparedMessages, args.localPath)
+
+  return {
+    messages: preparedMessages,
+    totalAttachmentCount,
+    bundledAttachmentCount,
+  }
+}
+
+function rewriteAttachmentAsMetadata(attachment: {
+  absolutePath: string
+  relativePath: string
+  contentUrl: string
+}) {
+  attachment.absolutePath = ""
+  attachment.relativePath = ""
+  attachment.contentUrl = ""
+}
+
+async function resolveUniqueExportDir(
+  exportRootDir: string,
+  title: string,
+  now: Date,
+  pathExists: (targetPath: string) => Promise<boolean>,
+) {
+  const baseName = `${sanitizeFileNameSegment(title) || "chat"}-${formatExportTimestamp(now)}`
+  let candidate = path.join(exportRootDir, baseName)
+  let suffix = 2
+
+  while (await pathExists(candidate)) {
+    candidate = path.join(exportRootDir, `${baseName}-${suffix}`)
+    suffix += 1
+  }
+
+  return candidate
+}
+
+function formatExportTimestamp(value: Date) {
+  return value
+    .toISOString()
+    .replace(/:/g, "-")
+    .replace(/\.\d{3}Z$/u, "Z")
+}
+
+function sanitizeFileNameSegment(value: string) {
+  return value
+    .trim()
+    .replace(/[^\w.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+}
+
+async function defaultPathExists(targetPath: string) {
+  try {
+    await stat(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function defaultReadDir(targetPath: string) {
+  return await readdir(targetPath, { withFileTypes: true })
+}
+
+async function uploadStandaloneExportDirectory(args: {
+  outputDir: string
+  shareSlug: string
+  uploadBaseUrl: string
+  fetch: FetchLike
+  pathExists: (targetPath: string) => Promise<boolean>
+  readDir: (targetPath: string) => Promise<Dirent[]>
+  readFile: typeof readFile
+}) {
+  const filePaths = await listShareUploadFiles(args.outputDir, args.readDir, args.pathExists)
+  let uploadedFileCount = 0
+
+  for (const filePath of filePaths) {
+    const relativePath = path.relative(args.outputDir, filePath).split(path.sep).join("/")
+    const body = await args.readFile(filePath)
+    const response = await args.fetch(buildShareUploadUrl(args.uploadBaseUrl, args.shareSlug, relativePath), {
+      method: "PUT",
+      headers: {
+        "Cache-Control": getShareUploadCacheControl(relativePath),
+        "Content-Type": getContentTypeForPath(relativePath),
+      },
+      body,
+    })
+
+    if (!response.ok) {
+      const detail = await response.text().catch(() => "")
+      const suffix = detail ? `: ${detail}` : ` (status ${response.status})`
+      throw new Error(`Failed to upload shared transcript file ${relativePath}${suffix}`)
+    }
+
+    uploadedFileCount += 1
+  }
+
+  return uploadedFileCount
+}
+
+async function listShareUploadFiles(
+  outputDir: string,
+  readDir: (targetPath: string) => Promise<Dirent[]>,
+  pathExists: (targetPath: string) => Promise<boolean>,
+): Promise<string[]> {
+  const filePaths = [path.join(outputDir, "transcript.json")]
+  const attachmentsDir = path.join(outputDir, "attachments")
+
+  if (await pathExists(attachmentsDir)) {
+    filePaths.push(...await listExportFiles(attachmentsDir, readDir))
+  }
+
+  return filePaths
+}
+
+async function listExportFiles(
+  rootDir: string,
+  readDir: (targetPath: string) => Promise<Dirent[]>,
+): Promise<string[]> {
+  const entries = await readDir(rootDir)
+  const files: string[] = []
+
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const entryPath = path.join(rootDir, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...await listExportFiles(entryPath, readDir))
+      continue
+    }
+    if (entry.isFile()) {
+      files.push(entryPath)
+    }
+  }
+
+  return files
+}
+
+function buildStandaloneShareSlug(title: string, providedSuffix?: string) {
+  const baseSlug = title
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64) || "chat"
+  const suffix = (providedSuffix ?? generateStandaloneShareSlugSuffix())
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "")
+    .slice(0, 12) || "share"
+  return `${baseSlug}-${suffix}`
+}
+
+function generateStandaloneShareSlugSuffix() {
+  return BigInt(`0x${randomBytes(8).toString("hex")}`).toString(36).slice(0, 10).padStart(10, "0")
+}
+
+function buildStandaloneShareUrl(baseUrl: string, shareSlug: string) {
+  return `${baseUrl.replace(/\/+$/u, "")}/${shareSlug}`
+}
+
+function buildShareUploadUrl(baseUrl: string, shareSlug: string, relativePath: string) {
+  const encodedSegments = [shareSlug, ...relativePath.split("/")].map((segment) => encodeURIComponent(segment))
+  return `${baseUrl.replace(/\/+$/u, "")}/${encodedSegments.join("/")}`
+}
+
+function getShareUploadCacheControl(relativePath: string) {
+  return STANDALONE_SHARE_ASSET_CACHE_CONTROL
+}
+
+function getContentTypeForPath(relativePath: string) {
+  return CONTENT_TYPES_BY_EXTENSION[path.extname(relativePath).toLowerCase()] ?? "application/octet-stream"
+}
+
+function rewriteLocalPathsForShare(value: unknown, localPath: string) {
+  if (!localPath) {
+    return
+  }
+
+  if (typeof value === "string") {
+    return value.replaceAll(localPath, STANDALONE_SHARE_WORKSPACE_PATH)
+  }
+
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      value[index] = rewriteLocalPathsForShare(value[index], localPath)
+    }
+    return value
+  }
+
+  if (!value || typeof value !== "object") {
+    return value
+  }
+
+  for (const [key, nestedValue] of Object.entries(value)) {
+    ;(value as Record<string, unknown>)[key] = rewriteLocalPathsForShare(nestedValue, localPath)
+  }
+
+  return value
+}

package/src/server/ws-router.ts

@@ -12,6 +12,7 @@ import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
 import { KeybindingsManager } from "./keybindings"
 import { ensureProjectDirectory, resolveLocalPath } from "./paths"
+import { writeStandaloneTranscriptExport } from "./standalone-export"
 import { TerminalManager } from "./terminal-manager"
 import type { UpdateManager } from "./update-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
@@ -1098,6 +1099,19 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           return
         }
+        case "chat.exportStandalone": {
+          const { chat, project } = resolveChatProject(command.chatId)
+          const result = await writeStandaloneTranscriptExport({
+            chatId: chat.id,
+            title: chat.title,
+            localPath: project.localPath,
+            theme: command.theme,
+            attachmentMode: command.attachmentMode,
+            messages: store.getMessages(command.chatId),
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          return
+        }
         case "chat.loadHistory": {
           const chat = store.getChat(command.chatId)
           if (!chat) throw new Error("Chat not found")

package/src/shared/branding.ts

@@ -6,6 +6,7 @@ export const PACKAGE_NAME = "kanna-code"
 export const RUNTIME_PROFILE_ENV_VAR = "KANNA_RUNTIME_PROFILE"
 // Read version from package.json — JSON import works in both Bun and Vite
 import pkg from "../../package.json"
+export const APP_VERSION = pkg.version
 export const SDK_CLIENT_APP = `kanna/${pkg.version}`
 export const LOG_PREFIX = "[kanna]"
 export const DEFAULT_NEW_PROJECT_ROOT = `~/${APP_NAME}`

package/src/shared/protocol.ts

@@ -11,6 +11,8 @@ import type {
   LocalProjectsSnapshot,
   ModelOptions,
   SidebarData,
+  StandaloneTranscriptAttachmentMode,
+  StandaloneTranscriptExportResult,
   UpdateSnapshot,
 } from "./types"
 
@@ -173,6 +175,12 @@ export type ClientCommand =
   | { type: "chat.ignoreDiffFile"; chatId: string; path: string }
   | { type: "chat.cancel"; chatId: string }
   | { type: "chat.stopDraining"; chatId: string }
+  | {
+      type: "chat.exportStandalone"
+      chatId: string
+      theme: "light" | "dark"
+      attachmentMode: StandaloneTranscriptAttachmentMode
+    }
   | { type: "chat.loadHistory"; chatId: string; beforeCursor: string; limit: number }
   | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
   | {
@@ -219,7 +227,7 @@ export type ServerSnapshot =
 export type ServerEnvelope =
   | { v: 1; type: "snapshot"; id: string; snapshot: ServerSnapshot }
   | { v: 1; type: "event"; id: string; event: TerminalEvent }
-  | { v: 1; type: "ack"; id: string; result?: unknown | ChatHistoryPage }
+  | { v: 1; type: "ack"; id: string; result?: unknown | ChatHistoryPage | StandaloneTranscriptExportResult }
   | { v: 1; type: "error"; id?: string; message: string }
 
 export function isClientEnvelope(value: unknown): value is ClientEnvelope {

package/src/shared/types.test.ts

@@ -12,7 +12,8 @@ describe("shared model normalization", () => {
     expect(normalizeClaudeModelId("haiku")).toBe("claude-haiku-4-5-20251001")
   })
 
-  test("normalizes legacy Codex aliases via the provider catalog", () => {
+  test("normalizes legacy Codex aliases and defaults to the latest catalog model", () => {
+    expect(normalizeCodexModelId()).toBe("gpt-5.5")
     expect(normalizeCodexModelId("gpt-5-codex")).toBe("gpt-5.3-codex")
   })
 

package/src/shared/types.ts

@@ -7,6 +7,8 @@ export const DEFAULT_OPENAI_SDK_MODEL = "gpt-5.4-mini"
 export const DEFAULT_OPENROUTER_SDK_MODEL = "moonshotai/kimi-k2.5:nitro"
 
 export type AttachmentKind = "image" | "file"
+export type StandaloneTranscriptAttachmentMode = "metadata" | "bundle"
+export type StandaloneTranscriptTheme = "light" | "dark"
 
 export interface ChatAttachment {
   id: string
@@ -19,6 +21,30 @@ export interface ChatAttachment {
   size: number
 }
 
+export interface StandaloneTranscriptBundle {
+  version: 1
+  chatId: string
+  title: string
+  localPath: string
+  exportedAt: string
+  viewerVersion: string
+  theme: StandaloneTranscriptTheme
+  attachmentMode: StandaloneTranscriptAttachmentMode
+  messages: TranscriptEntry[]
+}
+
+export interface StandaloneTranscriptExportResult {
+  outputDir: string
+  indexHtmlPath: string
+  transcriptJsonPath: string
+  attachmentMode: StandaloneTranscriptAttachmentMode
+  totalAttachmentCount: number
+  bundledAttachmentCount: number
+  shareSlug: string
+  shareUrl: string
+  uploadedFileCount: number
+}
+
 export interface QueuedChatMessage {
   id: string
   content: string
@@ -166,9 +192,10 @@ export const PROVIDERS: ProviderCatalogEntry[] = [
   {
     id: "codex",
     label: "Codex",
-    defaultModel: "gpt-5.4",
+    defaultModel: "gpt-5.5",
     supportsPlanMode: true,
     models: [
+      { id: "gpt-5.5", label: "GPT-5.5", supportsEffort: false },
       { id: "gpt-5.4", label: "GPT-5.4", supportsEffort: false },
       { id: "gpt-5.3-codex", label: "GPT-5.3 Codex", supportsEffort: false, aliases: ["gpt-5-codex"] },
       { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", supportsEffort: false },
@@ -207,7 +234,7 @@ export function normalizeClaudeModelId(modelId?: string, fallbackModelId = "clau
   return normalizeProviderModelId("claude", modelId, fallbackModelId)
 }
 
-export function normalizeCodexModelId(modelId?: string, fallbackModelId = "gpt-5.4"): string {
+export function normalizeCodexModelId(modelId?: string, fallbackModelId = "gpt-5.5"): string {
   return normalizeProviderModelId("codex", modelId, fallbackModelId)
 }