@cuongtran001/kanna 1.3.0 → 1.4.0

package/src/server/events.ts

@@ -649,6 +649,6 @@ export function createEmptyState(): StoreState {
   }
 }
 
-export function cloneTranscriptEntries(entries: TranscriptEntry[]): TranscriptEntry[] {
+export function cloneTranscriptEntries(entries: readonly TranscriptEntry[]): TranscriptEntry[] {
   return entries.map((entry) => ({ ...entry }))
 }

package/src/server/harness-types.ts

@@ -1,4 +1,4 @@
-import type { AccountInfo, AgentProvider, NormalizedToolCall, TranscriptEntry } from "../shared/types"
+import type { AccountInfo, AgentProvider, NormalizedToolCall, SlashCommand, TranscriptEntry } from "../shared/types"
 
 export interface HarnessEvent {
   type: "transcript" | "session_token" | "rate_limit"
@@ -18,3 +18,17 @@ export interface HarnessTurn {
   interrupt: () => Promise<void>
   close: () => void
 }
+
+export interface ClaudeSessionHandle {
+  provider: "claude"
+  stream: AsyncIterable<HarnessEvent>
+  getAccountInfo?: () => Promise<AccountInfo | null>
+  interrupt: () => Promise<void>
+  close: () => void
+  sendPrompt: (content: string) => Promise<void>
+  setModel: (model: string) => Promise<void>
+  setPermissionMode: (planMode: boolean) => Promise<void>
+  getSupportedCommands: () => Promise<SlashCommand[]>
+  /** Present only for keep-alive channel-delivery sessions; drives turn 2+. */
+  pushChannelPrompt?: (text: string) => Promise<void>
+}

package/src/server/oauth-errors.ts

@@ -0,0 +1,19 @@
+/**
+ * OAuth-pool error types shared between agent.ts and turn-spawning modules.
+ * Kept in a standalone file to avoid circular imports.
+ */
+
+/**
+ * Thrown by Claude spawn paths when the OAuth pool has tokens but every one
+ * is currently unusable (rate-limited, errored, disabled, or reserved by
+ * another chat). `startTurnForChat` catches this and persists `message` as a
+ * `result` transcript entry instead of letting it surface as an ephemeral
+ * commandError that gets wiped by the next chat snapshot tick.
+ */
+export class OAuthPoolUnavailableError extends Error {
+  readonly kind = "oauth_pool_unavailable" as const
+  constructor(message: string) {
+    super(message)
+    this.name = "OAuthPoolUnavailableError"
+  }
+}

package/src/server/storage/backend.ts

@@ -7,6 +7,13 @@ export interface StorageBackend {
   size(path: string): Promise<number>
   readText(path: string): Promise<string>
   readTextSync(path: string): string
+  /** Synchronous file size in bytes; 0 if missing. Optional (tail-read fast path). */
+  sizeSync?(path: string): number
+  /**
+   * Synchronous byte-range read `[start, endExclusive)`. Optional — callers
+   * MUST fall back to full reads when absent (tail-read fast path only).
+   */
+  readSliceSync?(path: string, start: number, endExclusive: number): Uint8Array
   writeText(path: string, content: string): Promise<void>
   appendText(path: string, content: string): Promise<void>
   rename(from: string, to: string): Promise<void>

package/src/server/storage/fs-storage.adapter.ts

@@ -1,5 +1,5 @@
 import { appendFile, mkdir, rename, rm } from "node:fs/promises"
-import { existsSync, readFileSync } from "node:fs"
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from "node:fs"
 import type { StorageBackend } from "./backend"
 
 export class FsStorageBackend implements StorageBackend {
@@ -27,6 +27,26 @@ export class FsStorageBackend implements StorageBackend {
     return readFileSync(path, "utf8")
   }
 
+  sizeSync(path: string): number {
+    try {
+      return statSync(path).size
+    } catch {
+      return 0
+    }
+  }
+
+  readSliceSync(path: string, start: number, endExclusive: number): Uint8Array {
+    const length = Math.max(0, endExclusive - start)
+    const buffer = Buffer.alloc(length)
+    const fd = openSync(path, "r")
+    try {
+      const bytesRead = readSync(fd, buffer, 0, length, start)
+      return buffer.subarray(0, bytesRead)
+    } finally {
+      closeSync(fd)
+    }
+  }
+
   async writeText(path: string, content: string): Promise<void> {
     await Bun.write(path, content)
   }

package/src/server/storage/in-memory-storage.ts

@@ -46,6 +46,18 @@ export class InMemoryStorageBackend implements StorageBackend {
     return content
   }
 
+  sizeSync(p: string): number {
+    const content = this.files.get(normalize(p))
+    if (content === undefined) return 0
+    return Buffer.byteLength(content, "utf8")
+  }
+
+  readSliceSync(p: string, start: number, endExclusive: number): Uint8Array {
+    const content = this.files.get(normalize(p))
+    if (content === undefined) return new Uint8Array(0)
+    return Uint8Array.prototype.slice.call(Buffer.from(content, "utf8"), start, endExclusive)
+  }
+
   async writeText(p: string, content: string): Promise<void> {
     const norm = normalize(p)
     this.files.set(norm, content)

package/src/server/ws-router-agent-ctrl.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, mock, test } from "bun:test"
+import type { AgentCtrlCommandDeps, AgentCtrlAgentDep, TunnelGatewayDep } from "./ws-router-agent-ctrl"
+import { handleAgentCtrlCommand } from "./ws-router-agent-ctrl"
+import type { ClientCommand } from "../shared/protocol"
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeAgent(overrides: Partial<AgentCtrlAgentDep> = {}): AgentCtrlAgentDep {
+  return {
+    acceptAutoContinue: mock(async () => {}),
+    rescheduleAutoContinue: mock(async () => {}),
+    cancelAutoContinue: mock(async () => {}),
+    cancel: mock(async () => {}),
+    ...overrides,
+  }
+}
+
+function makeTunnel(overrides: Partial<TunnelGatewayDep> = {}): TunnelGatewayDep {
+  return {
+    accept: mock(async () => {}),
+    stop: mock(async () => {}),
+    retry: mock(async () => {}),
+    ...overrides,
+  }
+}
+
+function makeDeps(
+  agentOverrides?: Partial<AgentCtrlAgentDep>,
+  tunnel?: TunnelGatewayDep | undefined,
+  killPty?: AgentCtrlCommandDeps["killPtyInstance"],
+): AgentCtrlCommandDeps & { sent: unknown[]; broadcasts: string[] } {
+  const sent: unknown[] = []
+  const broadcasts: string[] = []
+  return {
+    agent: makeAgent(agentOverrides),
+    tunnelGateway: tunnel,
+    killPtyInstance: killPty,
+    send: (envelope) => { sent.push(envelope) },
+    broadcastChatAndSidebar: async (chatId) => { broadcasts.push(chatId) },
+    sent,
+    broadcasts,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Unrecognized command
+// ---------------------------------------------------------------------------
+
+describe("handleAgentCtrlCommand", () => {
+  test("returns false for a non-agent-ctrl command", async () => {
+    const deps = makeDeps()
+    const handled = await handleAgentCtrlCommand(
+      deps,
+      { type: "settings.readAppSettings" } as unknown as ClientCommand,
+      "r0",
+    )
+    expect(handled).toBe(false)
+    expect(deps.sent).toHaveLength(0)
+    expect(deps.broadcasts).toHaveLength(0)
+  })
+
+  // ---------------------------------------------------------------------------
+  // autoContinue
+  // ---------------------------------------------------------------------------
+
+  test("autoContinue.accept — calls agent, acks, and broadcasts", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "autoContinue.accept", chatId: "c-1", scheduleId: "s-1", scheduledAt: 1234 }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r1")
+    expect(handled).toBe(true)
+    expect((deps.agent.acceptAutoContinue as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-1", "s-1", 1234)
+    expect(deps.sent).toHaveLength(1)
+    expect((deps.sent[0] as { type: string }).type).toBe("ack")
+    expect(deps.broadcasts).toEqual(["c-1"])
+  })
+
+  test("autoContinue.reschedule — calls agent, acks, and broadcasts", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "autoContinue.reschedule", chatId: "c-2", scheduleId: "s-2", scheduledAt: 5678 }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r2")
+    expect(handled).toBe(true)
+    expect((deps.agent.rescheduleAutoContinue as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-2", "s-2", 5678)
+    expect(deps.sent).toHaveLength(1)
+    expect(deps.broadcasts).toEqual(["c-2"])
+  })
+
+  test("autoContinue.cancel — calls agent with reason 'user', acks, and broadcasts", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "autoContinue.cancel", chatId: "c-3", scheduleId: "s-3" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r3")
+    expect(handled).toBe(true)
+    expect((deps.agent.cancelAutoContinue as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-3", "s-3", "user")
+    expect(deps.sent).toHaveLength(1)
+    expect(deps.broadcasts).toEqual(["c-3"])
+  })
+
+  // ---------------------------------------------------------------------------
+  // tunnel
+  // ---------------------------------------------------------------------------
+
+  test("tunnel.accept — calls tunnelGateway, acks, and broadcasts", async () => {
+    const tunnel = makeTunnel()
+    const deps = makeDeps(undefined, tunnel)
+    const cmd: ClientCommand = { type: "tunnel.accept", chatId: "c-4", tunnelId: "t-1" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r4")
+    expect(handled).toBe(true)
+    expect((tunnel.accept as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-4", "t-1")
+    expect(deps.sent).toHaveLength(1)
+    expect(deps.broadcasts).toEqual(["c-4"])
+  })
+
+  test("tunnel.accept — still acks and broadcasts when tunnelGateway is absent", async () => {
+    const deps = makeDeps(undefined, undefined)
+    const cmd: ClientCommand = { type: "tunnel.accept", chatId: "c-5", tunnelId: "t-2" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r5")
+    expect(handled).toBe(true)
+    expect(deps.sent).toHaveLength(1)
+    expect(deps.broadcasts).toEqual(["c-5"])
+  })
+
+  test("tunnel.stop — calls tunnelGateway, acks, and broadcasts", async () => {
+    const tunnel = makeTunnel()
+    const deps = makeDeps(undefined, tunnel)
+    const cmd: ClientCommand = { type: "tunnel.stop", chatId: "c-6", tunnelId: "t-3" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r6")
+    expect(handled).toBe(true)
+    expect((tunnel.stop as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-6", "t-3")
+    expect(deps.broadcasts).toEqual(["c-6"])
+  })
+
+  test("tunnel.retry — calls tunnelGateway, acks, and broadcasts", async () => {
+    const tunnel = makeTunnel()
+    const deps = makeDeps(undefined, tunnel)
+    const cmd: ClientCommand = { type: "tunnel.retry", chatId: "c-7", tunnelId: "t-4" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r7")
+    expect(handled).toBe(true)
+    expect((tunnel.retry as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-7", "t-4")
+    expect(deps.broadcasts).toEqual(["c-7"])
+  })
+
+  // ---------------------------------------------------------------------------
+  // pty
+  // ---------------------------------------------------------------------------
+
+  test("pty.cancel — acks {ok:true} on success", async () => {
+    const deps = makeDeps()
+    const cmd: ClientCommand = { type: "pty.cancel", chatId: "c-8" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r8")
+    expect(handled).toBe(true)
+    expect((deps.agent.cancel as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-8")
+    const ack = deps.sent[0] as { result: { ok: boolean } }
+    expect(ack.result.ok).toBe(true)
+  })
+
+  test("pty.cancel — acks {ok:false} when agent.cancel throws", async () => {
+    const deps = makeDeps({ cancel: mock(async () => { throw new Error("boom") }) })
+    const cmd: ClientCommand = { type: "pty.cancel", chatId: "c-9" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r9")
+    expect(handled).toBe(true)
+    const ack = deps.sent[0] as { result: { ok: boolean; error: string } }
+    expect(ack.result.ok).toBe(false)
+    expect(ack.result.error).toBe("boom")
+  })
+
+  test("pty.kill — returns {ok:false} error when killPtyInstance is absent", async () => {
+    const deps = makeDeps(undefined, undefined, undefined)
+    const cmd: ClientCommand = { type: "pty.kill", chatId: "c-10" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r10")
+    expect(handled).toBe(true)
+    const ack = deps.sent[0] as { result: { ok: boolean; error: string } }
+    expect(ack.result.ok).toBe(false)
+    expect(ack.result.error).toContain("not available")
+  })
+
+  test("pty.kill — delegates to killPtyInstance and acks with its result", async () => {
+    const killFn = mock(async (_chatId: string) => ({ ok: true }))
+    const deps = makeDeps(undefined, undefined, killFn)
+    const cmd: ClientCommand = { type: "pty.kill", chatId: "c-11" }
+    const handled = await handleAgentCtrlCommand(deps, cmd, "r11")
+    expect(handled).toBe(true)
+    expect(killFn).toHaveBeenCalledWith("c-11")
+    const ack = deps.sent[0] as { result: { ok: boolean } }
+    expect(ack.result.ok).toBe(true)
+  })
+})

package/src/server/ws-router-agent-ctrl.ts

@@ -0,0 +1,137 @@
+/**
+ * ws-router-agent-ctrl.ts
+ *
+ * WS command handlers for agent-control lifecycle operations:
+ *   autoContinue.accept, autoContinue.reschedule, autoContinue.cancel,
+ *   tunnel.accept, tunnel.stop, tunnel.retry,
+ *   pty.cancel, pty.kill
+ *
+ * Extracted from ws-router.ts.
+ */
+import { PROTOCOL_VERSION } from "../shared/types"
+import type { ClientCommand, ServerEnvelope } from "../shared/protocol"
+
+// ---------------------------------------------------------------------------
+// Dep interfaces (duck-typed; avoids circular imports with ws-router.ts)
+// ---------------------------------------------------------------------------
+
+/** The subset of AgentCoordinator methods consumed by agent-ctrl WS commands. */
+export interface AgentCtrlAgentDep {
+  acceptAutoContinue(chatId: string, scheduleId: string, scheduledAt: number): Promise<void>
+  rescheduleAutoContinue(chatId: string, scheduleId: string, scheduledAt: number): Promise<void>
+  cancelAutoContinue(chatId: string, scheduleId: string, reason: "user" | "chat_deleted"): Promise<void>
+  cancel(chatId: string): Promise<void>
+}
+
+/** The subset of TunnelGateway methods consumed by tunnel WS commands. */
+export interface TunnelGatewayDep {
+  accept(chatId: string, tunnelId: string): Promise<void>
+  stop(chatId: string, tunnelId: string): Promise<void>
+  retry(chatId: string, tunnelId: string): Promise<void>
+}
+
+export interface AgentCtrlCommandDeps {
+  /** Agent coordinator methods for autoContinue and pty commands. */
+  agent: AgentCtrlAgentDep
+  /** Optional tunnel gateway (may be absent if tunnels are not configured). */
+  tunnelGateway: TunnelGatewayDep | undefined
+  /** Optional PTY-instance kill function (absent in SDK-only deploys). */
+  killPtyInstance: ((chatId: string) => Promise<{ ok: boolean; error?: string }>) | undefined
+  /** Pre-bound to the current WebSocket; called to send an ack envelope. */
+  send: (envelope: ServerEnvelope) => void
+  /** Called after operations that change the chat/sidebar snapshot. */
+  broadcastChatAndSidebar: (chatId: string) => Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Command dispatcher
+// ---------------------------------------------------------------------------
+
+/**
+ * Handle one agent-control WS command.
+ *
+ * Returns `true` when the command was handled (caller should `return`).
+ * Returns `false` when the command type is outside this module's scope.
+ */
+export async function handleAgentCtrlCommand(
+  deps: AgentCtrlCommandDeps,
+  command: ClientCommand,
+  id: string,
+): Promise<boolean> {
+  const { agent, tunnelGateway, killPtyInstance, send, broadcastChatAndSidebar } = deps
+
+  switch (command.type) {
+    case "autoContinue.accept": {
+      await agent.acceptAutoContinue(command.chatId, command.scheduleId, command.scheduledAt)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "autoContinue.reschedule": {
+      await agent.rescheduleAutoContinue(command.chatId, command.scheduleId, command.scheduledAt)
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "autoContinue.cancel": {
+      await agent.cancelAutoContinue(command.chatId, command.scheduleId, "user")
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "tunnel.accept": {
+      if (tunnelGateway) {
+        await tunnelGateway.accept(command.chatId, command.tunnelId)
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "tunnel.stop": {
+      if (tunnelGateway) {
+        await tunnelGateway.stop(command.chatId, command.tunnelId)
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "tunnel.retry": {
+      if (tunnelGateway) {
+        await tunnelGateway.retry(command.chatId, command.tunnelId)
+      }
+      send({ v: PROTOCOL_VERSION, type: "ack", id })
+      await broadcastChatAndSidebar(command.chatId)
+      return true
+    }
+    case "pty.cancel": {
+      try {
+        await agent.cancel(command.chatId)
+        send({ v: PROTOCOL_VERSION, type: "ack", id, result: { ok: true } })
+      } catch (err) {
+        send({
+          v: PROTOCOL_VERSION,
+          type: "ack",
+          id,
+          result: { ok: false, error: err instanceof Error ? err.message : String(err) },
+        })
+      }
+      return true
+    }
+    case "pty.kill": {
+      if (!killPtyInstance) {
+        send({
+          v: PROTOCOL_VERSION,
+          type: "ack",
+          id,
+          result: { ok: false, error: "pty kill not available" },
+        })
+        return true
+      }
+      const result = await killPtyInstance(command.chatId)
+      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
+      return true
+    }
+    default:
+      return false
+  }
+}