kanna-code 0.16.0 → 0.18.0

package/src/server/server.ts

@@ -1,5 +1,7 @@
 import path from "node:path"
+import { stat } from "node:fs/promises"
 import { APP_NAME, getRuntimeProfile } from "../shared/branding"
+import type { ChatAttachment } from "../shared/types"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
 import { discoverProjects, type DiscoveredProject } from "./discovery"
@@ -9,6 +11,45 @@ import { TerminalManager } from "./terminal-manager"
 import { UpdateManager } from "./update-manager"
 import type { UpdateInstallAttemptResult } from "./cli-runtime"
 import { createWsRouter, type ClientState } from "./ws-router"
+import { deleteProjectUpload, inferAttachmentContentType, persistProjectUpload } from "./uploads"
+import { getProjectUploadDir } from "./paths"
+
+const MAX_UPLOAD_FILES = 10
+const MAX_UPLOAD_SIZE_BYTES = 25 * 1024 * 1024
+
+export async function persistUploadedFiles(args: {
+  projectId: string
+  localPath: string
+  files: File[]
+  persistUpload?: typeof persistProjectUpload
+}): Promise<ChatAttachment[]> {
+  const persistUpload = args.persistUpload ?? persistProjectUpload
+  const attachments: ChatAttachment[] = []
+
+  try {
+    for (const file of args.files) {
+      const bytes = new Uint8Array(await file.arrayBuffer())
+      const attachment = await persistUpload({
+        projectId: args.projectId,
+        localPath: args.localPath,
+        fileName: file.name,
+        bytes,
+        fallbackMimeType: file.type || undefined,
+      })
+      attachments.push(attachment)
+    }
+  } catch (error) {
+    await Promise.allSettled(
+      attachments.map((attachment) => deleteProjectUpload({
+        localPath: args.localPath,
+        storedName: path.basename(attachment.absolutePath),
+      }))
+    )
+    throw error
+  }
+
+  return attachments
+}
 
 export interface StartKannaServerOptions {
   port?: number
@@ -79,7 +120,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
       server = Bun.serve<ClientState>({
         port: actualPort,
         hostname,
-        fetch(req, serverInstance) {
+        async fetch(req, serverInstance) {
           const url = new URL(req.url)
 
           if (url.pathname === "/ws") {
@@ -95,6 +136,21 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
             return Response.json({ ok: true, port: actualPort })
           }
 
+          const uploadResponse = await handleProjectUpload(req, url, store)
+          if (uploadResponse) {
+            return uploadResponse
+          }
+
+          const deleteUploadResponse = await handleProjectUploadDelete(req, url, store)
+          if (deleteUploadResponse) {
+            return deleteUploadResponse
+          }
+
+          const attachmentContentResponse = await handleAttachmentContent(req, url, store)
+          if (attachmentContentResponse) {
+            return attachmentContentResponse
+          }
+
           return serveStatic(distDir, url.pathname)
         },
         websocket: {
@@ -140,6 +196,127 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   }
 }
 
+async function handleProjectUpload(req: Request, url: URL, store: EventStore) {
+  if (req.method !== "POST") {
+    return null
+  }
+
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/uploads$/)
+  if (!match) {
+    return null
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const formData = await req.formData()
+  const files = formData
+    .getAll("files")
+    .filter((value): value is File => value instanceof File)
+
+  if (files.length === 0) {
+    return Response.json({ error: "No files uploaded" }, { status: 400 })
+  }
+
+  if (files.length > MAX_UPLOAD_FILES) {
+    return Response.json({ error: `You can upload up to ${MAX_UPLOAD_FILES} files at a time.` }, { status: 400 })
+  }
+
+  for (const file of files) {
+    if (file.size > MAX_UPLOAD_SIZE_BYTES) {
+      return Response.json(
+        { error: `File "${file.name}" exceeds the ${Math.floor(MAX_UPLOAD_SIZE_BYTES / (1024 * 1024))} MB limit.` },
+        { status: 413 }
+      )
+    }
+  }
+
+  try {
+    const attachments = await persistUploadedFiles({
+      projectId: project.id,
+      localPath: project.localPath,
+      files,
+    })
+    return Response.json({ attachments })
+  } catch (error) {
+    console.error("[uploads] Upload failed:", error)
+    return Response.json({ error: "Upload failed" }, { status: 500 })
+  }
+}
+
+async function handleAttachmentContent(req: Request, url: URL, store: EventStore) {
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/uploads\/([^/]+)\/content$/)
+  if (!match) {
+    return null
+  }
+
+  if (req.method !== "GET") {
+    return new Response(null, {
+      status: 405,
+      headers: {
+        Allow: "GET",
+      },
+    })
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const storedName = decodeURIComponent(match[2])
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return Response.json({ error: "Invalid attachment path" }, { status: 400 })
+  }
+
+  const filePath = path.join(getProjectUploadDir(project.localPath), storedName)
+  const file = Bun.file(filePath)
+  try {
+    const info = await stat(filePath)
+    if (!info.isFile()) {
+      return Response.json({ error: "Attachment not found" }, { status: 404 })
+    }
+  } catch {
+    return Response.json({ error: "Attachment not found" }, { status: 404 })
+  }
+
+  return new Response(file, {
+    headers: {
+      "Content-Type": inferAttachmentContentType(storedName, file.type),
+    },
+  })
+}
+
+async function handleProjectUploadDelete(req: Request, url: URL, store: EventStore) {
+  if (req.method !== "DELETE") {
+    return null
+  }
+
+  const match = url.pathname.match(/^\/api\/projects\/([^/]+)\/uploads\/([^/]+)$/)
+  if (!match) {
+    return null
+  }
+
+  const project = store.getProject(match[1])
+  if (!project) {
+    return Response.json({ error: "Project not found" }, { status: 404 })
+  }
+
+  const storedName = decodeURIComponent(match[2])
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return Response.json({ error: "Invalid attachment path" }, { status: 400 })
+  }
+
+  const deleted = await deleteProjectUpload({
+    localPath: project.localPath,
+    storedName,
+  })
+
+  return Response.json({ ok: deleted })
+}
+
 async function serveStatic(distDir: string, pathname: string) {
   const requestedPath = pathname === "/" ? "/index.html" : pathname
   const filePath = path.join(distDir, requestedPath)

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)
+}