@cuongtran001/kanna 0.43.2 → 0.45.0

package/src/server/agent.ts

@@ -1,4 +1,6 @@
 import { query, type CanUseTool, type PermissionResult, type Query, type SDKUserMessage } from "@anthropic-ai/claude-agent-sdk"
+import { createKannaMcpServer } from "./kanna-mcp"
+import { KANNA_MCP_SERVER_NAME } from "../shared/tools"
 import { homedir } from "node:os"
 import type {
   AgentProvider,
@@ -34,6 +36,8 @@ import { ClaudeLimitDetector, CodexLimitDetector, type LimitDetection, type Limi
 import type { ScheduleManager } from "./auto-continue/schedule-manager"
 import { deriveChatSchedules } from "./auto-continue/read-model"
 import type { TunnelGateway } from "./cloudflare-tunnel/gateway"
+import type { BackgroundTaskRegistry } from "./background-tasks"
+import type { TerminalManager } from "./terminal-manager"
 
 const CLAUDE_TOOLSET = [
   "Skill",
@@ -111,9 +115,11 @@ interface AgentCoordinatorArgs {
   onStateChange: (chatId?: string, options?: { immediate?: boolean }) => void
   analytics?: AnalyticsReporter
   codexManager?: CodexAppServerManager
+  terminalManager?: TerminalManager
   generateTitle?: (messageContent: string, cwd: string) => Promise<GenerateChatTitleResult>
   tunnelGateway?: TunnelGateway
   startClaudeSession?: (args: {
+    projectId: string
     localPath: string
     model: string
     effort?: string
@@ -127,6 +133,7 @@ interface AgentCoordinatorArgs {
   scheduleManager?: ScheduleManager
   getAutoResumePreference?: () => boolean
   throwOnClaudeSessionStart?: boolean
+  backgroundTasks?: BackgroundTaskRegistry
 }
 
 interface SendToStartingProfile {
@@ -583,6 +590,7 @@ class AsyncMessageQueue<T> implements AsyncIterable<T> {
 }
 
 async function startClaudeSession(args: {
+  projectId: string
   localPath: string
   model: string
   effort?: string
@@ -659,6 +667,12 @@ async function startClaudeSession(args: {
       permissionMode: args.planMode ? "plan" : "acceptEdits",
       canUseTool,
       tools: [...CLAUDE_TOOLSET],
+      mcpServers: {
+        [KANNA_MCP_SERVER_NAME]: createKannaMcpServer({
+          projectId: args.projectId,
+          localPath: args.localPath,
+        }),
+      },
       systemPrompt: {
         type: "preset",
         preset: "claude_code",
@@ -715,11 +729,50 @@ async function startClaudeSession(args: {
   }
 }
 
+function parseBackgroundPid(output: string): number | null {
+  const match = output.match(/\bpid[\s:=]+(\d+)\b/i)
+  return match ? Number(match[1]) : null
+}
+
+function parseBackgroundShellId(output: string): string | null {
+  const match = output.match(/shell[_\s-]?id[:\s]+([\w-]+)/i)
+  return match ? match[1] : null
+}
+
+/**
+ * Extracts the canonical background task ID from a tool_result content value.
+ *
+ * The SDK may surface `backgroundTaskId` either:
+ *  - as a top-level field on a BashOutput object (the direct-object form), or
+ *  - as a field on one of the items in a content-block array.
+ *
+ * Returns the first non-empty string found, or null if absent.
+ */
+function extractBackgroundTaskId(content: unknown): string | null {
+  if (content === null || typeof content !== "object") return null
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (typeof item === "object" && item !== null && "backgroundTaskId" in item) {
+        const id = (item as { backgroundTaskId?: unknown }).backgroundTaskId
+        if (typeof id === "string" && id.length > 0) return id
+      }
+    }
+    return null
+  }
+  // Direct BashOutput-like object
+  if ("backgroundTaskId" in content) {
+    const id = (content as { backgroundTaskId?: unknown }).backgroundTaskId
+    if (typeof id === "string" && id.length > 0) return id
+  }
+  return null
+}
+
 export class AgentCoordinator {
   private readonly store: EventStore
   private readonly onStateChange: (chatId?: string, options?: { immediate?: boolean }) => void
   private readonly analytics: AnalyticsReporter
   private readonly codexManager: CodexAppServerManager
+  private readonly terminalManager: TerminalManager | null
   private readonly generateTitle: (messageContent: string, cwd: string) => Promise<GenerateChatTitleResult>
   private readonly startClaudeSessionFn: NonNullable<AgentCoordinatorArgs["startClaudeSession"]>
   private reportBackgroundError: ((message: string) => void) | null = null
@@ -734,13 +787,17 @@ export class AgentCoordinator {
   private readonly throwOnClaudeSessionStart: boolean
   private readonly autoResumeByChat = new Map<string, boolean>()
   private readonly tunnelGateway: TunnelGateway | null
-  private readonly pendingBashCalls = new Map<string, { command: string; chatId: string }>()
+  private readonly backgroundTasks: BackgroundTaskRegistry | null
+  private readonly pendingBashCalls = new Map<string, { command: string; chatId: string; isBg: boolean }>()
 
   constructor(args: AgentCoordinatorArgs) {
     this.store = args.store
     this.onStateChange = args.onStateChange
     this.analytics = args.analytics ?? NoopAnalyticsReporter
-    this.codexManager = args.codexManager ?? new CodexAppServerManager()
+    this.codexManager = args.codexManager ?? new CodexAppServerManager({
+      backgroundTasks: args.backgroundTasks,
+    })
+    this.terminalManager = args.terminalManager ?? null
     this.generateTitle = args.generateTitle ?? generateTitleForChatDetailed
     this.startClaudeSessionFn = args.startClaudeSession ?? startClaudeSession
     this.claudeLimitDetector = args.claudeLimitDetector ?? new ClaudeLimitDetector()
@@ -749,6 +806,18 @@ export class AgentCoordinator {
     this.getAutoResumePreference = args.getAutoResumePreference ?? (() => false)
     this.throwOnClaudeSessionStart = args.throwOnClaudeSessionStart ?? false
     this.tunnelGateway = args.tunnelGateway ?? null
+    this.backgroundTasks = args.backgroundTasks ?? null
+    this.backgroundTasks?.setStrategies({
+      closeStream: async (task) => {
+        await this.stopDraining(task.chatId)
+      },
+      killPty: async (task) => {
+        this.terminalManager?.close(task.ptyId)
+      },
+      shutdownCodex: async (task) => {
+        this.codexManager.stopSession(task.chatId)
+      },
+    })
   }
 
   setBackgroundErrorReporter(report: ((message: string) => void) | null) {
@@ -790,11 +859,10 @@ export class AgentCoordinator {
   }
 
   private trackBashToolEntry(chatId: string, entry: TranscriptEntry): void {
-    if (!this.tunnelGateway) return
-
     if (entry.kind === "tool_call" && entry.tool.toolKind === "bash") {
       const command = entry.tool.input.command ?? ""
-      this.pendingBashCalls.set(entry.tool.toolId, { command, chatId })
+      const isBg = entry.tool.input.runInBackground === true
+      this.pendingBashCalls.set(entry.tool.toolId, { command, chatId, isBg })
       return
     }
 
@@ -803,12 +871,35 @@ export class AgentCoordinator {
       if (!pending) return
       this.pendingBashCalls.delete(entry.toolId)
       const stdout = stringifyToolResultContent(entry.content)
-      void this.tunnelGateway.handleBashResult({
-        command: pending.command,
-        stdout,
-        chatId: pending.chatId,
-        sourcePid: null,
-      })
+
+      if (this.tunnelGateway) {
+        void this.tunnelGateway.handleBashResult({
+          command: pending.command,
+          stdout,
+          chatId: pending.chatId,
+          sourcePid: null,
+        })
+      }
+
+      if (pending.isBg && this.backgroundTasks) {
+        const registryId = `bash:${entry.toolId}`
+        const shellId =
+          extractBackgroundTaskId(entry.content) ??
+          parseBackgroundShellId(stdout) ??
+          entry.toolId
+        const pid = parseBackgroundPid(stdout)
+        this.backgroundTasks.register({
+          kind: "bash_shell",
+          id: registryId,
+          chatId: pending.chatId,
+          command: pending.command,
+          shellId,
+          pid,
+          startedAt: Date.now(),
+          lastOutput: stdout.slice(-1024),
+          status: "running",
+        })
+      }
     }
   }
 
@@ -824,11 +915,16 @@ export class AgentCoordinator {
     }
   }
 
+  private clearDrainingStream(chatId: string): void {
+    this.drainingStreams.delete(chatId)
+    this.backgroundTasks?.unregister(`drain:${chatId}`)
+  }
+
   async stopDraining(chatId: string) {
     const draining = this.drainingStreams.get(chatId)
     if (!draining) return
     draining.turn.close()
-    this.drainingStreams.delete(chatId)
+    this.clearDrainingStream(chatId)
     this.emitStateChange(chatId)
   }
 
@@ -853,6 +949,7 @@ export class AgentCoordinator {
         const defaultModel = normalizeServerModel("claude")
         const defaultOptions = normalizeClaudeModelOptions(defaultModel)
         const ephemeral = await this.startClaudeSessionFn({
+          projectId: project.id,
           localPath: project.localPath,
           model: resolveClaudeApiModelId(defaultModel, defaultOptions.contextWindow),
           effort: defaultOptions.reasoningEffort,
@@ -984,7 +1081,7 @@ export class AgentCoordinator {
     const draining = this.drainingStreams.get(args.chatId)
     if (draining) {
       draining.turn.close()
-      this.drainingStreams.delete(args.chatId)
+      this.clearDrainingStream(args.chatId)
     }
 
     const chat = this.store.requireChat(args.chatId)
@@ -1070,6 +1167,7 @@ export class AgentCoordinator {
       })
       turn = await this.startClaudeTurn({
         chatId: args.chatId,
+        projectId: project.id,
         localPath: project.localPath,
         model: args.model,
         effort: args.effort,
@@ -1198,6 +1296,7 @@ export class AgentCoordinator {
 
   private async startClaudeTurn(args: {
     chatId: string
+    projectId: string
     localPath: string
     model: string
     effort?: string
@@ -1215,6 +1314,7 @@ export class AgentCoordinator {
       }
 
       const started = await this.startClaudeSessionFn({
+        projectId: args.projectId,
         localPath: args.localPath,
         model: args.model,
         effort: args.effort,
@@ -1503,7 +1603,13 @@ export class AgentCoordinator {
         }
       }
     } finally {
-      this.claudeSessions.delete(session.chatId)
+      // Only clear the chat's session slot if it still points at us. A cancel
+      // followed by an immediate steer can install a fresh session under the
+      // same chatId before this finally runs; deleting unconditionally would
+      // wipe the new session.
+      if (this.claudeSessions.get(session.chatId) === session) {
+        this.claudeSessions.delete(session.chatId)
+      }
       const active = this.activeTurns.get(session.chatId)
       if (active?.provider === "claude") {
         if (active.cancelRequested && !active.cancelRecorded) {
@@ -1582,6 +1688,13 @@ export class AgentCoordinator {
           // Track the still-open stream so the UI can show a draining
           // indicator and the user can stop background tasks.
           this.drainingStreams.set(active.chatId, { turn: active.turn })
+          this.backgroundTasks?.register({
+            kind: "draining_stream",
+            id: `drain:${active.chatId}`,
+            chatId: active.chatId,
+            startedAt: Date.now(),
+            lastOutput: "",
+          })
         }
 
         this.emitStateChange(active.chatId)
@@ -1618,7 +1731,7 @@ export class AgentCoordinator {
         this.activeTurns.delete(active.chatId)
       }
       // Stream has fully ended — no longer draining.
-      this.drainingStreams.delete(active.chatId)
+      this.clearDrainingStream(active.chatId)
       this.emitStateChange(active.chatId)
 
       if (active.postToolFollowUp && !active.cancelRequested) {
@@ -1824,7 +1937,7 @@ export class AgentCoordinator {
     const draining = this.drainingStreams.get(chatId)
     if (draining) {
       draining.turn.close()
-      this.drainingStreams.delete(chatId)
+      this.clearDrainingStream(chatId)
     }
 
     const active = this.activeTurns.get(chatId)
@@ -1866,6 +1979,20 @@ export class AgentCoordinator {
     // Remove from activeTurns immediately so the UI reflects the cancellation
     // right away, rather than waiting for interrupt() which may hang.
     this.activeTurns.delete(chatId)
+
+    // Drain the cancelled prompt's seq from the Claude session's pending
+    // queue. The SDK does not always echo a `result.subtype=cancelled` for
+    // an interrupted prompt — when the stream just ends, the seq would
+    // otherwise linger and cause a FIFO mismatch when the next turn's
+    // result arrives, leaving the chat stuck in "running".
+    if (active.provider === "claude" && active.claudePromptSeq != null) {
+      const session = this.claudeSessions.get(chatId)
+      if (session) {
+        const idx = session.pendingPromptSeqs.indexOf(active.claudePromptSeq)
+        if (idx >= 0) session.pendingPromptSeqs.splice(idx, 1)
+      }
+    }
+
     this.emitStateChange(chatId)
     logClaudeSteer("cancel_active_turn_deleted", {
       chatId,

package/src/server/app-settings.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test"
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import path from "node:path"
-import { AUTH_DEFAULTS, CLOUDFLARE_TUNNEL_DEFAULTS } from "../shared/types"
+import { AUTH_DEFAULTS, CLOUDFLARE_TUNNEL_DEFAULTS, UPLOAD_DEFAULTS } from "../shared/types"
 import { AppSettingsManager, readAppSettingsSnapshot } from "./app-settings"
 import type { AppSettingsSnapshot } from "../shared/types"
 
@@ -63,6 +63,7 @@ function expectedSettingsSnapshot(filePath: string, overrides: Partial<AppSettin
     filePathDisplay: filePath,
     cloudflareTunnel: CLOUDFLARE_TUNNEL_DEFAULTS,
     auth: AUTH_DEFAULTS,
+    uploads: UPLOAD_DEFAULTS,
     ...overrides,
   }
 }
@@ -232,3 +233,55 @@ describe("cloudflareTunnel normalization", () => {
     })
   })
 })
+
+describe("uploads normalization", () => {
+  test("returns defaults when uploads block missing", async () => {
+    const filePath = await writeSettingsFile({ analyticsEnabled: true })
+    const snapshot = await readAppSettingsSnapshot(filePath)
+    expect(snapshot.uploads).toEqual({ maxFileSizeMb: 100 })
+  })
+
+  test("preserves valid maxFileSizeMb", async () => {
+    const filePath = await writeSettingsFile({ uploads: { maxFileSizeMb: 250 } })
+    const snapshot = await readAppSettingsSnapshot(filePath)
+    expect(snapshot.uploads.maxFileSizeMb).toBe(250)
+  })
+
+  test("clamps out-of-range values and emits warning", async () => {
+    const filePath = await writeSettingsFile({ uploads: { maxFileSizeMb: 99999 } })
+    const snapshot = await readAppSettingsSnapshot(filePath)
+    expect(snapshot.uploads.maxFileSizeMb).toBe(2048)
+    expect(snapshot.warning).toContain("uploads.maxFileSizeMb")
+  })
+
+  test("rejects non-number maxFileSizeMb and falls back to default", async () => {
+    const filePath = await writeSettingsFile({ uploads: { maxFileSizeMb: "big" } })
+    const snapshot = await readAppSettingsSnapshot(filePath)
+    expect(snapshot.uploads.maxFileSizeMb).toBe(100)
+    expect(snapshot.warning).toContain("uploads.maxFileSizeMb must be a number")
+  })
+
+  test("setUploads persists patch and round-trips through readAppSettingsSnapshot", async () => {
+    const filePath = await writeSettingsFile({ analyticsEnabled: true })
+    const manager = new AppSettingsManager(filePath)
+    await manager.initialize()
+    await manager.setUploads({ maxFileSizeMb: 500 })
+    const reloaded = await readAppSettingsSnapshot(filePath)
+    expect(reloaded.uploads.maxFileSizeMb).toBe(500)
+    manager.dispose()
+  })
+
+  test("setUploads throws on invalid value", async () => {
+    const filePath = await createTempFilePath()
+    const manager = new AppSettingsManager(filePath)
+    await manager.initialize()
+    let lowError: unknown
+    try { await manager.setUploads({ maxFileSizeMb: 0 }) } catch (error) { lowError = error }
+    expect((lowError as Error)?.message).toMatch(/between/)
+    let highError: unknown
+    try { await manager.setUploads({ maxFileSizeMb: 99999 }) } catch (error) { highError = error }
+    expect((highError as Error)?.message).toMatch(/between/)
+    manager.dispose()
+  })
+})
+

package/src/server/app-settings.ts

@@ -17,6 +17,9 @@ import {
   normalizeClaudeModelId,
   normalizeCodexModelId,
   supportsClaudeMaxReasoningEffort,
+  UPLOAD_DEFAULTS,
+  UPLOAD_MAX_FILE_SIZE_MB_MAX,
+  UPLOAD_MAX_FILE_SIZE_MB_MIN,
   type AppSettingsPatch,
   type AppSettingsSnapshot,
   type AppThemePreference,
@@ -30,6 +33,7 @@ import {
   type DefaultProviderPreference,
   type EditorPreset,
   type ProviderPreference,
+  type UploadSettings,
 } from "../shared/types"
 
 interface AppSettingsFile {
@@ -54,6 +58,7 @@ interface AppSettingsFile {
   }
   cloudflareTunnel?: unknown
   auth?: unknown
+  uploads?: unknown
 }
 
 interface AppSettingsState extends AppSettingsSnapshot {
@@ -278,6 +283,30 @@ function normalizeAuthSettings(value: unknown, warnings: string[]): AuthSettings
   return { sessionMaxAgeDays }
 }
 
+function normalizeUploadSettings(value: unknown, warnings: string[]): UploadSettings {
+  const source = value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+  if (value !== undefined && !source) {
+    warnings.push("uploads must be an object")
+  }
+
+  const rawSize = source?.maxFileSizeMb
+  let maxFileSizeMb = UPLOAD_DEFAULTS.maxFileSizeMb
+  if (rawSize !== undefined) {
+    if (typeof rawSize !== "number" || !Number.isFinite(rawSize)) {
+      warnings.push("uploads.maxFileSizeMb must be a number")
+    } else if (rawSize < UPLOAD_MAX_FILE_SIZE_MB_MIN || rawSize > UPLOAD_MAX_FILE_SIZE_MB_MAX) {
+      warnings.push(`uploads.maxFileSizeMb must be between ${UPLOAD_MAX_FILE_SIZE_MB_MIN} and ${UPLOAD_MAX_FILE_SIZE_MB_MAX}`)
+      maxFileSizeMb = clampNumber(rawSize, UPLOAD_DEFAULTS.maxFileSizeMb, UPLOAD_MAX_FILE_SIZE_MB_MIN, UPLOAD_MAX_FILE_SIZE_MB_MAX)
+    } else {
+      maxFileSizeMb = Math.round(rawSize)
+    }
+  }
+
+  return { maxFileSizeMb }
+}
+
 function toFilePayload(state: AppSettingsState) {
   return {
     analyticsEnabled: state.analyticsEnabled,
@@ -292,6 +321,7 @@ function toFilePayload(state: AppSettingsState) {
     providerDefaults: state.providerDefaults,
     cloudflareTunnel: state.cloudflareTunnel,
     auth: state.auth,
+    uploads: state.uploads,
   }
 }
 
@@ -310,6 +340,7 @@ function toSnapshot(state: AppSettingsState): AppSettingsSnapshot {
     filePathDisplay: state.filePathDisplay,
     cloudflareTunnel: state.cloudflareTunnel,
     auth: state.auth,
+    uploads: state.uploads,
   }
 }
 
@@ -342,6 +373,7 @@ function normalizeAppSettings(
 
   const cloudflareTunnel = normalizeCloudflareTunnel(source?.cloudflareTunnel, warnings)
   const auth = normalizeAuthSettings(source?.auth, warnings)
+  const uploads = normalizeUploadSettings(source?.uploads, warnings)
 
   const editorPreset = normalizeEditorPreset(source?.editor?.preset)
   const state: AppSettingsState = {
@@ -365,6 +397,7 @@ function normalizeAppSettings(
     filePathDisplay: formatDisplayPath(filePath),
     cloudflareTunnel,
     auth,
+    uploads,
   }
 
   const shouldWrite = JSON.stringify(source ? toComparablePayload(source) : null) !== JSON.stringify(toFilePayload(state))
@@ -393,6 +426,7 @@ function toComparablePayload(source: AppSettingsFile) {
     providerDefaults: source.providerDefaults,
     cloudflareTunnel: source.cloudflareTunnel,
     auth: source.auth,
+    uploads: source.uploads,
   }
 }
 
@@ -434,6 +468,10 @@ function applyPatch(state: AppSettingsState, patch: AppSettingsPatch): AppSettin
       ...state.auth,
       ...patch.auth,
     },
+    uploads: {
+      ...state.uploads,
+      ...patch.uploads,
+    },
   }, state.filePathDisplay).payload
 }
 
@@ -528,6 +566,17 @@ export class AppSettingsManager {
     return this.writePatch({ auth: patch })
   }
 
+  async setUploads(patch: Partial<UploadSettings>) {
+    if (patch.maxFileSizeMb !== undefined) {
+      const value = patch.maxFileSizeMb
+      if (typeof value !== "number" || !Number.isFinite(value)
+        || value < UPLOAD_MAX_FILE_SIZE_MB_MIN || value > UPLOAD_MAX_FILE_SIZE_MB_MAX) {
+        throw new Error(`uploads.maxFileSizeMb must be between ${UPLOAD_MAX_FILE_SIZE_MB_MIN} and ${UPLOAD_MAX_FILE_SIZE_MB_MAX}`)
+      }
+    }
+    return this.writePatch({ uploads: patch })
+  }
+
   async writePatch(patch: AppSettingsPatch) {
     const nextState = {
       ...applyPatch(this.state, patch),

package/src/server/auth.test.ts

@@ -39,7 +39,29 @@ function extractCookie(response: Response) {
 
 describe("password auth", () => {
   test("serves the app shell to unauthenticated browser requests", async () => {
-    const { server } = await startPasswordServer()
+    // Create a minimal client bundle fixture so the static file handler can serve it.
+    // In CI, `bun run build` produces dist/client/index.html before tests run.
+    // Locally (no prior build) we inject a temp distDir via the test-only option.
+    const distDir = await mkdtemp(path.join(tmpdir(), "kanna-dist-"))
+    tempDirs.push(distDir)
+    await writeFile(
+      path.join(distDir, "index.html"),
+      '<!DOCTYPE html><html><body><div id="root"></div></body></html>',
+      "utf8",
+    )
+
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-auth-test-"))
+    const dataDir = await mkdtemp(path.join(tmpdir(), "kanna-auth-data-"))
+    tempDirs.push(projectDir, dataDir)
+    const server = await startKannaServer({
+      dataDir,
+      distDir,
+      port: 4320,
+      strictPort: true,
+      password: "secret",
+      trustProxy: false,
+    })
+    await server.store.openProject(projectDir, "Project")
 
     try {
       const response = await fetch(`http://localhost:${server.port}/chat/demo`, { headers: { Accept: "text/html" } })