kanna-code 0.1.0

package/src/server/generate-title.ts

@@ -0,0 +1,42 @@
+import { query } from "@anthropic-ai/claude-agent-sdk"
+
+export async function generateTitleForChat(messageContent: string): Promise<string | null> {
+  try {
+    const q = query({
+      prompt: `Generate a short, descriptive title (under 60 chars) for a conversation that starts with this message. Return JSON matching the schema.\n\n${messageContent}`,
+      options: {
+        model: "haiku",
+        tools: [],
+        systemPrompt: "",
+        permissionMode: "bypassPermissions",
+        outputFormat: {
+          type: "json_schema",
+          schema: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+            },
+            required: ["title"],
+            additionalProperties: false,
+          },
+        },
+        env: { ...process.env },
+      },
+    })
+
+    try {
+      for await (const message of q) {
+        if ("result" in message) {
+          const output = (message as Record<string, unknown>).structured_output as { title?: string } | undefined
+          return typeof output?.title === "string" ? output.title.slice(0, 80) : null
+        }
+      }
+    } finally {
+      q.close()
+    }
+
+    return null
+  } catch {
+    return null
+  }
+}

package/src/server/machine-name.ts

@@ -0,0 +1,22 @@
+import { hostname } from "node:os"
+import process from "node:process"
+import { spawnSync } from "node:child_process"
+
+function runAndRead(command: string, args: string[]) {
+  const result = spawnSync(command, args, { encoding: "utf8" })
+  if (result.status !== 0) return null
+  const value = result.stdout.trim()
+  return value || null
+}
+
+export function getMachineDisplayName() {
+  if (process.platform === "darwin") {
+    const computerName = runAndRead("scutil", ["--get", "ComputerName"])
+    if (computerName) {
+      return computerName
+    }
+  }
+
+  const rawHostname = hostname().trim()
+  return rawHostname.replace(/\.local$|\.lan$/i, "") || "This Machine"
+}

package/src/server/paths.ts

@@ -0,0 +1,27 @@
+import { mkdir, stat } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+
+export function resolveLocalPath(localPath: string) {
+  const trimmed = localPath.trim()
+  if (!trimmed) {
+    throw new Error("Project path is required")
+  }
+  if (trimmed === "~") {
+    return homedir()
+  }
+  if (trimmed.startsWith("~/")) {
+    return path.join(homedir(), trimmed.slice(2))
+  }
+  return path.resolve(trimmed)
+}
+
+export async function ensureProjectDirectory(localPath: string) {
+  const resolvedPath = resolveLocalPath(localPath)
+
+  await mkdir(resolvedPath, { recursive: true })
+  const info = await stat(resolvedPath)
+  if (!info.isDirectory()) {
+    throw new Error("Project path must be a directory")
+  }
+}

package/src/server/read-models.ts

@@ -0,0 +1,120 @@
+import type {
+  ChatRuntime,
+  ChatSnapshot,
+  KannaStatus,
+  LocalProjectsSnapshot,
+  SidebarChatRow,
+  SidebarData,
+  SidebarProjectGroup,
+} from "../shared/types"
+import type { ChatRecord, StoreState } from "./events"
+import { cloneTranscriptEntries } from "./events"
+import { resolveLocalPath } from "./paths"
+
+export function deriveStatus(chat: ChatRecord, activeStatus?: KannaStatus): KannaStatus {
+  if (activeStatus) return activeStatus
+  if (chat.lastTurnOutcome === "failed") return "failed"
+  return "idle"
+}
+
+export function deriveSidebarData(
+  state: StoreState,
+  activeStatuses: Map<string, KannaStatus>
+): SidebarData {
+  const projects = [...state.projectsById.values()]
+    .filter((project) => !project.deletedAt)
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+
+  const projectGroups: SidebarProjectGroup[] = projects.map((project) => {
+    const chats: SidebarChatRow[] = [...state.chatsById.values()]
+      .filter((chat) => chat.projectId === project.id && !chat.deletedAt)
+      .sort((a, b) => (b.lastMessageAt ?? b.updatedAt) - (a.lastMessageAt ?? a.updatedAt))
+      .map((chat) => ({
+        _id: chat.id,
+        _creationTime: chat.createdAt,
+        chatId: chat.id,
+        title: chat.title,
+        status: deriveStatus(chat, activeStatuses.get(chat.id)),
+        localPath: project.localPath,
+        lastMessageAt: chat.lastMessageAt,
+        hasAutomation: false,
+      }))
+
+    return {
+      groupKey: project.id,
+      localPath: project.localPath,
+      chats,
+    }
+  }).filter((group) => group.chats.length > 0)
+
+  return { projectGroups }
+}
+
+export function deriveLocalProjectsSnapshot(
+  state: StoreState,
+  discoveredProjects: Array<{ localPath: string; title: string; modifiedAt: number }>,
+  machineName: string
+): LocalProjectsSnapshot {
+  const projects = new Map<string, LocalProjectsSnapshot["projects"][number]>()
+
+  for (const project of discoveredProjects) {
+    const normalizedPath = resolveLocalPath(project.localPath)
+    projects.set(normalizedPath, {
+      localPath: normalizedPath,
+      title: project.title,
+      source: "discovered",
+      lastOpenedAt: project.modifiedAt,
+      chatCount: 0,
+    })
+  }
+
+  for (const project of [...state.projectsById.values()].filter((entry) => !entry.deletedAt)) {
+    const chats = [...state.chatsById.values()].filter((chat) => chat.projectId === project.id && !chat.deletedAt)
+    const lastOpenedAt = chats.reduce(
+      (latest, chat) => Math.max(latest, chat.lastMessageAt ?? chat.updatedAt ?? 0),
+      project.updatedAt
+    )
+
+    projects.set(project.localPath, {
+      localPath: project.localPath,
+      title: project.title,
+      source: "saved",
+      lastOpenedAt,
+      chatCount: chats.length,
+    })
+  }
+
+  return {
+    machine: {
+      id: "local",
+      displayName: machineName,
+    },
+    projects: [...projects.values()].sort((a, b) => (b.lastOpenedAt ?? 0) - (a.lastOpenedAt ?? 0)),
+  }
+}
+
+export function deriveChatSnapshot(
+  state: StoreState,
+  activeStatuses: Map<string, KannaStatus>,
+  chatId: string
+): ChatSnapshot | null {
+  const chat = state.chatsById.get(chatId)
+  if (!chat || chat.deletedAt) return null
+  const project = state.projectsById.get(chat.projectId)
+  if (!project || project.deletedAt) return null
+
+  const runtime: ChatRuntime = {
+    chatId: chat.id,
+    projectId: project.id,
+    localPath: project.localPath,
+    title: chat.title,
+    status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    planMode: chat.planMode,
+    resumeSessionId: chat.resumeSessionId,
+  }
+
+  return {
+    runtime,
+    messages: cloneTranscriptEntries(state.messagesByChatId.get(chat.id) ?? []),
+  }
+}

package/src/server/server.ts

@@ -0,0 +1,132 @@
+import path from "node:path"
+import { APP_NAME } from "../shared/branding"
+import { EventStore } from "./event-store"
+import { AgentCoordinator } from "./agent"
+import { discoverClaudeProjects, type DiscoveredProject } from "./discovery"
+import { getMachineDisplayName } from "./machine-name"
+import { createWsRouter, type ClientState } from "./ws-router"
+
+export interface StartKannaServerOptions {
+  port?: number
+}
+
+export async function startKannaServer(options: StartKannaServerOptions = {}) {
+  const port = options.port ?? 3210
+  const store = new EventStore()
+  const machineDisplayName = getMachineDisplayName()
+  await store.initialize()
+  let discoveredProjects: DiscoveredProject[] = []
+
+  async function refreshDiscovery() {
+    discoveredProjects = discoverClaudeProjects()
+    return discoveredProjects
+  }
+
+  await refreshDiscovery()
+
+  let server: ReturnType<typeof Bun.serve<ClientState>>
+  let router: ReturnType<typeof createWsRouter>
+  const agent = new AgentCoordinator({
+    store,
+    onStateChange: () => {
+      router.broadcastSnapshots()
+    },
+  })
+  router = createWsRouter({
+    store,
+    agent,
+    refreshDiscovery,
+    getDiscoveredProjects: () => discoveredProjects,
+    machineDisplayName,
+  })
+
+  const distDir = path.join(import.meta.dir, "..", "..", "dist", "client")
+
+  const MAX_PORT_ATTEMPTS = 20
+  let actualPort = port
+
+  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    try {
+      server = Bun.serve<ClientState>({
+        port: actualPort,
+        fetch(req, serverInstance) {
+          const url = new URL(req.url)
+
+          if (url.pathname === "/ws") {
+            const upgraded = serverInstance.upgrade(req, {
+              data: {
+                subscriptions: new Map(),
+              },
+            })
+            return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 })
+          }
+
+          if (url.pathname === "/health") {
+            return Response.json({ ok: true, port: actualPort })
+          }
+
+          return serveStatic(distDir, url.pathname)
+        },
+        websocket: {
+          open(ws) {
+            router.handleOpen(ws)
+          },
+          message(ws, raw) {
+            router.handleMessage(ws, raw)
+          },
+          close(ws) {
+            router.handleClose(ws)
+          },
+        },
+      })
+      break
+    } catch (err: unknown) {
+      const isAddrInUse =
+        err instanceof Error && "code" in err && (err as NodeJS.ErrnoException).code === "EADDRINUSE"
+      if (!isAddrInUse || attempt === MAX_PORT_ATTEMPTS - 1) {
+        throw err
+      }
+      console.log(`Port ${actualPort} is in use, trying ${actualPort + 1}...`)
+      actualPort++
+    }
+  }
+
+  const shutdown = async () => {
+    for (const chatId of [...agent.activeTurns.keys()]) {
+      await agent.cancel(chatId)
+    }
+    await store.compact()
+    server.stop(true)
+  }
+
+  return {
+    port: actualPort,
+    store,
+    stop: shutdown,
+  }
+}
+
+async function serveStatic(distDir: string, pathname: string) {
+  const requestedPath = pathname === "/" ? "/index.html" : pathname
+  const filePath = path.join(distDir, requestedPath)
+  const indexPath = path.join(distDir, "index.html")
+
+  const file = Bun.file(filePath)
+  if (await file.exists()) {
+    return new Response(file)
+  }
+
+  const indexFile = Bun.file(indexPath)
+  if (await indexFile.exists()) {
+    return new Response(indexFile, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+      },
+    })
+  }
+
+  return new Response(
+    `${APP_NAME} client bundle not found. Run \`bun run build\` inside workbench/ first.`,
+    { status: 503 }
+  )
+}

package/src/server/ws-router.ts

@@ -0,0 +1,208 @@
+import type { ServerWebSocket } from "bun"
+import { PROTOCOL_VERSION } from "../shared/types"
+import type { ClientEnvelope, ServerEnvelope, SubscriptionTopic } from "../shared/protocol"
+import { isClientEnvelope } from "../shared/protocol"
+import type { AgentCoordinator } from "./agent"
+import type { DiscoveredProject } from "./discovery"
+import { EventStore } from "./event-store"
+import { openExternal } from "./external-open"
+import { ensureProjectDirectory } from "./paths"
+import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
+
+export interface ClientState {
+  subscriptions: Map<string, SubscriptionTopic>
+}
+
+interface CreateWsRouterArgs {
+  store: EventStore
+  agent: AgentCoordinator
+  refreshDiscovery: () => Promise<DiscoveredProject[]>
+  getDiscoveredProjects: () => DiscoveredProject[]
+  machineDisplayName: string
+}
+
+function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
+  ws.send(JSON.stringify(message))
+}
+
+export function createWsRouter({
+  store,
+  agent,
+  refreshDiscovery,
+  getDiscoveredProjects,
+  machineDisplayName,
+}: CreateWsRouterArgs) {
+  const sockets = new Set<ServerWebSocket<ClientState>>()
+
+  function createEnvelope(id: string, topic: SubscriptionTopic): ServerEnvelope {
+    if (topic.type === "sidebar") {
+      return {
+        v: PROTOCOL_VERSION,
+        type: "snapshot",
+        id,
+        snapshot: {
+          type: "sidebar",
+          data: deriveSidebarData(store.state, agent.getActiveStatuses()),
+        },
+      }
+    }
+
+    if (topic.type === "local-projects") {
+      const discoveredProjects = getDiscoveredProjects()
+      const data = deriveLocalProjectsSnapshot(store.state, discoveredProjects, machineDisplayName)
+
+      return {
+        v: PROTOCOL_VERSION,
+        type: "snapshot",
+        id,
+        snapshot: {
+          type: "local-projects",
+          data,
+        },
+      }
+    }
+
+    return {
+      v: PROTOCOL_VERSION,
+      type: "snapshot",
+      id,
+      snapshot: {
+        type: "chat",
+        data: deriveChatSnapshot(store.state, agent.getActiveStatuses(), topic.chatId),
+      },
+    }
+  }
+
+  function pushSnapshots(ws: ServerWebSocket<ClientState>) {
+    for (const [id, topic] of ws.data.subscriptions.entries()) {
+      send(ws, createEnvelope(id, topic))
+    }
+  }
+
+  function broadcastSnapshots() {
+    for (const ws of sockets) {
+      pushSnapshots(ws)
+    }
+  }
+
+  async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
+    const { command, id } = message
+    try {
+      switch (command.type) {
+        case "project.open": {
+          await ensureProjectDirectory(command.localPath)
+          const project = await store.openProject(command.localPath)
+          await refreshDiscovery()
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id } })
+          break
+        }
+        case "project.create": {
+          await ensureProjectDirectory(command.localPath)
+          const project = await store.openProject(command.localPath, command.title)
+          await refreshDiscovery()
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { projectId: project.id } })
+          break
+        }
+        case "project.remove": {
+          for (const chat of store.listChatsByProject(command.projectId)) {
+            await agent.cancel(chat.id)
+          }
+          await store.removeProject(command.projectId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+        case "system.openExternal": {
+          openExternal(command.localPath, command.action)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+        case "chat.create": {
+          const chat = await store.createChat(command.projectId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: { chatId: chat.id } })
+          break
+        }
+        case "chat.rename": {
+          await store.renameChat(command.chatId, command.title)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+        case "chat.delete": {
+          await agent.cancel(command.chatId)
+          await store.deleteChat(command.chatId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+        case "chat.send": {
+          const result = await agent.send(command)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result })
+          break
+        }
+        case "chat.cancel": {
+          await agent.cancel(command.chatId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+        case "chat.setPlanMode": {
+          await store.setPlanMode(command.chatId, command.planMode)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+        case "chat.respondTool": {
+          await agent.respondTool(command)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          break
+        }
+      }
+
+      broadcastSnapshots()
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : String(error)
+      send(ws, { v: PROTOCOL_VERSION, type: "error", id, message: messageText })
+    }
+  }
+
+  return {
+    handleOpen(ws: ServerWebSocket<ClientState>) {
+      sockets.add(ws)
+    },
+    handleClose(ws: ServerWebSocket<ClientState>) {
+      sockets.delete(ws)
+    },
+    broadcastSnapshots,
+    handleMessage(ws: ServerWebSocket<ClientState>, raw: string | Buffer | ArrayBuffer | Uint8Array) {
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(String(raw))
+      } catch {
+        send(ws, { v: PROTOCOL_VERSION, type: "error", message: "Invalid JSON" })
+        return
+      }
+
+      if (!isClientEnvelope(parsed)) {
+        send(ws, { v: PROTOCOL_VERSION, type: "error", message: "Invalid envelope" })
+        return
+      }
+
+      if (parsed.type === "subscribe") {
+        ws.data.subscriptions.set(parsed.id, parsed.topic)
+        if (parsed.topic.type === "local-projects") {
+          void refreshDiscovery().then(() => {
+            if (ws.data.subscriptions.has(parsed.id)) {
+              send(ws, createEnvelope(parsed.id, parsed.topic))
+            }
+          })
+        }
+        send(ws, createEnvelope(parsed.id, parsed.topic))
+        return
+      }
+
+      if (parsed.type === "unsubscribe") {
+        ws.data.subscriptions.delete(parsed.id)
+        send(ws, { v: PROTOCOL_VERSION, type: "ack", id: parsed.id })
+        return
+      }
+
+      void handleCommand(ws, parsed)
+    },
+  }
+}

package/src/shared/branding.ts

@@ -0,0 +1,23 @@
+export const APP_NAME = "Kanna"
+export const CLI_COMMAND = "kanna"
+export const DATA_ROOT_NAME = ".kanna"
+export const PACKAGE_NAME = "kanna-code"
+export const SDK_CLIENT_APP = "kanna/0.1.0"
+export const LOG_PREFIX = "[kanna]"
+export const DEFAULT_NEW_PROJECT_ROOT = `~/${APP_NAME}`
+
+export function getDataRootName() {
+  return DATA_ROOT_NAME
+}
+
+export function getDataDir(homeDir: string) {
+  return `${homeDir}/${DATA_ROOT_NAME}/data`
+}
+
+export function getDataDirDisplay() {
+  return `~/${DATA_ROOT_NAME.slice(1)}/data`
+}
+
+export function getCliInvocation(arg?: string) {
+  return arg ? `${CLI_COMMAND} ${arg}` : CLI_COMMAND
+}

package/src/shared/ports.ts

@@ -0,0 +1,3 @@
+export const PROD_SERVER_PORT = 3210
+export const DEV_SERVER_PORT = 3211
+export const DEV_CLIENT_PORT = 5174

package/src/shared/protocol.ts

@@ -0,0 +1,40 @@
+import type { ChatSnapshot, LocalProjectsSnapshot, SidebarData } from "./types"
+
+export type SubscriptionTopic =
+  | { type: "sidebar" }
+  | { type: "local-projects" }
+  | { type: "chat"; chatId: string }
+
+export type ClientCommand =
+  | { type: "project.open"; localPath: string }
+  | { type: "project.create"; localPath: string; title: string }
+  | { type: "project.remove"; projectId: string }
+  | { type: "system.openExternal"; localPath: string; action: "open_finder" | "open_terminal" | "open_editor" }
+  | { type: "chat.create"; projectId: string }
+  | { type: "chat.rename"; chatId: string; title: string }
+  | { type: "chat.delete"; chatId: string }
+  | { type: "chat.send"; chatId?: string; projectId?: string; content: string }
+  | { type: "chat.cancel"; chatId: string }
+  | { type: "chat.setPlanMode"; chatId: string; planMode: boolean }
+  | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
+
+export type ClientEnvelope =
+  | { v: 1; type: "subscribe"; id: string; topic: SubscriptionTopic }
+  | { v: 1; type: "unsubscribe"; id: string }
+  | { v: 1; type: "command"; id: string; command: ClientCommand }
+
+export type ServerSnapshot =
+  | { type: "sidebar"; data: SidebarData }
+  | { type: "local-projects"; data: LocalProjectsSnapshot }
+  | { type: "chat"; data: ChatSnapshot | null }
+
+export type ServerEnvelope =
+  | { v: 1; type: "snapshot"; id: string; snapshot: ServerSnapshot }
+  | { v: 1; type: "ack"; id: string; result?: unknown }
+  | { v: 1; type: "error"; id?: string; message: string }
+
+export function isClientEnvelope(value: unknown): value is ClientEnvelope {
+  if (!value || typeof value !== "object") return false
+  const candidate = value as Partial<ClientEnvelope>
+  return candidate.v === 1 && typeof candidate.type === "string"
+}