npm - kanna-code - Versions diffs - 0.26.4 → 0.26.6 - Mend

kanna-code 0.26.4 → 0.26.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/client/assets/{index-DDI3pFzk.js → index-CcdP0kaK.js} +195 -195
package/dist/client/index.html +1 -1
package/package.json +1 -1
package/src/server/diff-store.test.ts +46 -0
package/src/server/diff-store.ts +29 -2
package/src/server/event-store.test.ts +102 -5
package/src/server/event-store.ts +73 -17
package/src/server/ws-router.test.ts +80 -0
package/src/server/ws-router.ts +28 -3
package/src/shared/protocol.ts +1 -0
package/src/shared/types.ts +1 -0

package/dist/client/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>Kanna</title>
-    <script type="module" crossorigin src="/assets/index-DDI3pFzk.js"></script>
+    <script type="module" crossorigin src="/assets/index-CcdP0kaK.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C5RBxQW4.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "kanna-code",
   "type": "module",
-  "version": "0.26.4",
+  "version": "0.26.6",
   "description": "A beautiful web UI for Claude Code",
   "license": "MIT",
   "keywords": [

package/src/server/diff-store.test.ts CHANGED Viewed

@@ -148,6 +148,52 @@ describe("DiffStore", () => {
     expect((await run(["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], repoRoot)).trim()).toBe("origin/feature/publish-me")
   })
+  test("commit_and_push degrades to a local commit when origin is missing", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "base\n", "utf8")
+    await run(["git", "add", "."], repoRoot)
+    await run(["git", "commit", "-m", "init"], repoRoot)
+    await writeFile(path.join(repoRoot, "app.txt"), "changed\n", "utf8")
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("project-1", repoRoot)
+    const result = await store.commitFiles({
+      projectId: "project-1",
+      projectPath: repoRoot,
+      paths: ["app.txt"],
+      summary: "Local only",
+      mode: "commit_and_push",
+    })
+    expect(result).toMatchObject({
+      ok: true,
+      mode: "commit_and_push",
+      pushed: false,
+    })
+    expect((await run(["git", "log", "-1", "--pretty=%s"], repoRoot)).trim()).toBe("Local only")
+  })
+  test("refreshSnapshot reports origin presence before the first commit", async () => {
+    const repoRoot = await createRepo()
+    tempDirs.push(repoRoot)
+    await run(["git", "remote", "add", "origin", "https://github.com/jakemor/test224.git"], repoRoot)
+    await writeFile(path.join(repoRoot, "poem.md"), "rose\n", "utf8")
+    const store = new DiffStore(repoRoot)
+    await store.initialize()
+    await store.refreshSnapshot("project-1", repoRoot)
+    expect(store.getProjectSnapshot("project-1")).toMatchObject({
+      status: "ready",
+      branchName: "main",
+      hasOriginRemote: true,
+      originRepoSlug: "jakemor/test224",
+    })
+  })
   test("detects renamed files", async () => {
     const repoRoot = await createRepo()
     tempDirs.push(repoRoot)

package/src/server/diff-store.ts CHANGED Viewed

@@ -37,6 +37,7 @@ function createEmptyState(): StoredChatDiffState {
     status: "unknown",
     branchName: undefined,
     defaultBranchName: undefined,
+    hasOriginRemote: undefined,
     originRepoSlug: undefined,
     hasUpstream: undefined,
     aheadCount: undefined,
@@ -50,6 +51,7 @@ function createEmptyState(): StoredChatDiffState {
 function branchMetadataEqual(left: BranchMetadata, right: BranchMetadata) {
   return left.branchName === right.branchName
     && left.defaultBranchName === right.defaultBranchName
+    && left.hasOriginRemote === right.hasOriginRemote
     && left.originRepoSlug === right.originRepoSlug
     && left.hasUpstream === right.hasUpstream
 }
@@ -196,6 +198,9 @@ function createPushFailure(mode: DiffCommitMode, detail: string, snapshotChanged
   if (normalized.includes("non-fast-forward") || normalized.includes("fetch first")) {
     title = "Branch is not up to date"
     message = "Your branch is behind its remote. Pull or rebase, then try pushing again."
+  } else if (normalized.includes("does not appear to be a git repository")) {
+    title = "No origin remote configured"
+    message = "This repository does not have an origin remote configured."
   } else if (normalized.includes("has no upstream branch") || normalized.includes("set-upstream")) {
     title = "No upstream branch configured"
     message = "This branch does not have an upstream remote branch configured yet."
@@ -1317,6 +1322,7 @@ export class DiffStore {
       status: state.status,
       branchName: state.branchName,
       defaultBranchName: state.defaultBranchName,
+      hasOriginRemote: state.hasOriginRemote,
       originRepoSlug: state.originRepoSlug,
       hasUpstream: state.hasUpstream,
       aheadCount: state.aheadCount,
@@ -1339,6 +1345,7 @@ export class DiffStore {
         status: "no_repo",
         branchName: undefined,
         defaultBranchName: undefined,
+        hasOriginRemote: undefined,
         originRepoSlug: undefined,
         hasUpstream: undefined,
         aheadCount: undefined,
@@ -1356,6 +1363,7 @@ export class DiffStore {
     const branchName = await getBranchName(repo.repoRoot)
     const defaultBranchName = await resolveDefaultBranchName(repo.repoRoot)
     const originRemoteUrl = await getOriginRemoteUrl(repo.repoRoot)
+    const hasOriginRemote = originRemoteUrl !== null
     const originRepoSlug = extractGitHubRepoSlug(originRemoteUrl) ?? undefined
     const hasUpstream = await hasUpstreamBranch(repo.repoRoot)
     const { aheadCount, behindCount } = hasUpstream
@@ -1373,6 +1381,7 @@ export class DiffStore {
       status: "ready",
       branchName,
       defaultBranchName,
+      hasOriginRemote,
       originRepoSlug,
       hasUpstream,
       aheadCount,
@@ -1808,7 +1817,11 @@ export class DiffStore {
       throw new Error("Project is not in a git repository")
     }
-    const hasUpstream = await hasUpstreamBranch(repo.repoRoot)
+    const [hasUpstream, originRemoteUrl] = await Promise.all([
+      hasUpstreamBranch(repo.repoRoot),
+      getOriginRemoteUrl(repo.repoRoot),
+    ])
+    const hasOriginRemote = originRemoteUrl !== null
     if (args.action === "publish") {
       const publishResult = await runGit(["push", "-u", "origin", "HEAD"], repo.repoRoot)
       if (publishResult.exitCode !== 0) {
@@ -2002,7 +2015,11 @@ export class DiffStore {
     if (!repo) {
       throw new Error("Project is not in a git repository")
     }
-    const hasUpstream = await hasUpstreamBranch(repo.repoRoot)
+    const [hasUpstream, originRemoteUrl] = await Promise.all([
+      hasUpstreamBranch(repo.repoRoot),
+      getOriginRemoteUrl(repo.repoRoot),
+    ])
+    const hasOriginRemote = originRemoteUrl !== null
     const currentDirtyPaths = new Set((await listDirtyPaths(repo.repoRoot)).map((entry) => entry.path))
     const missingPaths = normalizedPaths.filter((relativePath) => !currentDirtyPaths.has(relativePath))
@@ -2039,6 +2056,16 @@ export class DiffStore {
       } satisfies DiffCommitResult
     }
+    if (!hasUpstream && !hasOriginRemote) {
+      return {
+        ok: true,
+        mode: args.mode,
+        branchName,
+        pushed: false,
+        snapshotChanged,
+      } satisfies DiffCommitResult
+    }
     const pushResult = hasUpstream
       ? await runGit(["push"], repo.repoRoot)
       : await runGit(["push", "-u", "origin", "HEAD"], repo.repoRoot)

package/src/server/event-store.test.ts CHANGED Viewed

@@ -191,6 +191,86 @@ describe("EventStore", () => {
     expect(reloaded.getChat(chat.id)?.unread).toBe(true)
   })
+  test("preserves read state after a finished turn across restart", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    await store.recordTurnFinished(chat.id)
+    await store.setChatReadState(chat.id, false)
+    expect(store.getChat(chat.id)?.unread).toBe(false)
+    const reloaded = new EventStore(dataDir)
+    await reloaded.initialize()
+    expect(reloaded.getChat(chat.id)?.unread).toBe(false)
+  })
+  test("preserves read state after a failed turn across restart", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    await store.recordTurnFailed(chat.id, "boom")
+    await store.setChatReadState(chat.id, false)
+    expect(store.getChat(chat.id)?.unread).toBe(false)
+    const reloaded = new EventStore(dataDir)
+    await reloaded.initialize()
+    expect(reloaded.getChat(chat.id)?.unread).toBe(false)
+  })
+  test("prefers mark-read over turn completion when replay timestamps tie", async () => {
+    const dataDir = await createTempDataDir()
+    const chatsLogPath = join(dataDir, "chats.jsonl")
+    const turnsLogPath = join(dataDir, "turns.jsonl")
+    const projectId = "project-1"
+    const chatId = "chat-1"
+    const timestamp = 100
+    await writeFile(chatsLogPath, [
+      JSON.stringify({
+        v: 2,
+        type: "chat_created",
+        timestamp,
+        chatId,
+        projectId,
+        title: "Chat",
+      }),
+      JSON.stringify({
+        v: 2,
+        type: "chat_read_state_set",
+        timestamp,
+        chatId,
+        unread: false,
+      }),
+      "",
+    ].join("\n"), "utf8")
+    await writeFile(turnsLogPath, [
+      JSON.stringify({
+        v: 2,
+        type: "turn_finished",
+        timestamp,
+        chatId,
+      }),
+      "",
+    ].join("\n"), "utf8")
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    expect(store.getChat(chatId)?.unread).toBe(false)
+  })
   test("loads chats without unread from older snapshots as read", async () => {
     const dataDir = await createTempDataDir()
     const snapshotPath = join(dataDir, "snapshot.json")
@@ -226,14 +306,14 @@ describe("EventStore", () => {
     expect(store.getChat("chat-1")?.unread).toBe(false)
   })
-  test("prunes stale empty chats after five minutes", async () => {
+  test("prunes stale empty chats after thirty minutes", async () => {
     const dataDir = await createTempDataDir()
     const store = new EventStore(dataDir)
     await store.initialize()
     const project = await store.openProject("/tmp/project")
     const chat = await store.createChat(project.id)
-    const staleNow = chat.createdAt + 5 * 60 * 1000
+    const staleNow = chat.createdAt + 30 * 60 * 1000
     const pruned = await store.pruneStaleEmptyChats({ now: staleNow })
@@ -248,7 +328,7 @@ describe("EventStore", () => {
     const project = await store.openProject("/tmp/project")
     const chat = await store.createChat(project.id)
-    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 5 * 60 * 1000 - 1 })
+    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 30 * 60 * 1000 - 1 })
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
@@ -263,7 +343,7 @@ describe("EventStore", () => {
     const chat = await store.createChat(project.id)
     await store.appendMessage(chat.id, entry("user_prompt", chat.createdAt + 1, { content: "hello" }))
-    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 5 * 60 * 1000 })
+    const pruned = await store.pruneStaleEmptyChats({ now: chat.createdAt + 30 * 60 * 1000 })
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
@@ -278,11 +358,28 @@ describe("EventStore", () => {
     const chat = await store.createChat(project.id)
     const pruned = await store.pruneStaleEmptyChats({
-      now: chat.createdAt + 5 * 60 * 1000,
+      now: chat.createdAt + 30 * 60 * 1000,
       activeChatIds: [chat.id],
     })
     expect(pruned).toEqual([])
     expect(store.getChat(chat.id)?.id).toBe(chat.id)
   })
+  test("does not prune stale chats with protected draft state", async () => {
+    const dataDir = await createTempDataDir()
+    const store = new EventStore(dataDir)
+    await store.initialize()
+    const project = await store.openProject("/tmp/project")
+    const chat = await store.createChat(project.id)
+    const pruned = await store.pruneStaleEmptyChats({
+      now: chat.createdAt + 30 * 60 * 1000,
+      protectedChatIds: [chat.id],
+    })
+    expect(pruned).toEqual([])
+    expect(store.getChat(chat.id)?.id).toBe(chat.id)
+  })
 })

package/src/server/event-store.ts CHANGED Viewed

@@ -7,7 +7,6 @@ import type { AgentProvider, ChatHistoryPage, ChatHistorySnapshot, TranscriptEnt
 import { STORE_VERSION } from "../shared/types"
 import {
   type ChatEvent,
-  type MessageEvent,
   type ProjectEvent,
   type SnapshotFile,
   type StoreEvent,
@@ -19,7 +18,7 @@ import {
 import { resolveLocalPath } from "./paths"
 const COMPACTION_THRESHOLD_BYTES = 2 * 1024 * 1024
-const STALE_EMPTY_CHAT_MAX_AGE_MS = 5 * 60 * 1000
+const STALE_EMPTY_CHAT_MAX_AGE_MS = 30 * 60 * 1000
 interface LegacyTranscriptStats {
   hasLegacyData: boolean
   sources: Array<"snapshot" | "messages_log">
@@ -33,6 +32,41 @@ interface TranscriptPageResult {
   olderCursor: string | null
 }
+interface ParsedReplayEvent {
+  event: StoreEvent
+  sourceIndex: number
+  lineIndex: number
+}
+function getReplayEventPriority(event: StoreEvent) {
+  switch (event.type) {
+    case "project_opened":
+    case "project_removed":
+      return 0
+    case "chat_created":
+      return 1
+    case "chat_renamed":
+    case "chat_provider_set":
+    case "chat_plan_mode_set":
+      return 2
+    case "message_appended":
+      return 3
+    case "turn_started":
+      return 4
+    case "session_token_set":
+      return 5
+    case "turn_cancelled":
+      return 6
+    case "turn_finished":
+    case "turn_failed":
+      return 7
+    case "chat_read_state_set":
+      return 8
+    case "chat_deleted":
+      return 9
+  }
+}
 function encodeHistoryCursor(index: number) {
   return `idx:${index}`
 }
@@ -166,21 +200,33 @@ export class EventStore {
   private async replayLogs() {
     if (this.storageReset) return
-    await this.replayLog<ProjectEvent>(this.projectsLogPath)
-    if (this.storageReset) return
-    await this.replayLog<ChatEvent>(this.chatsLogPath)
-    if (this.storageReset) return
-    await this.replayLog<MessageEvent>(this.messagesLogPath)
+    const replayEvents = [
+      ...await this.loadReplayEvents(this.projectsLogPath, 0),
+      ...await this.loadReplayEvents(this.chatsLogPath, 1),
+      ...await this.loadReplayEvents(this.messagesLogPath, 2),
+      ...await this.loadReplayEvents(this.turnsLogPath, 3),
+    ]
     if (this.storageReset) return
-    await this.replayLog<TurnEvent>(this.turnsLogPath)
+    replayEvents
+      .sort((left, right) => (
+        left.event.timestamp - right.event.timestamp
+        || getReplayEventPriority(left.event) - getReplayEventPriority(right.event)
+        || left.sourceIndex - right.sourceIndex
+        || left.lineIndex - right.lineIndex
+      ))
+      .forEach(({ event }) => {
+        this.applyEvent(event)
+      })
   }
-  private async replayLog<TEvent extends StoreEvent>(filePath: string) {
+  private async loadReplayEvents(filePath: string, sourceIndex: number): Promise<ParsedReplayEvent[]> {
     const file = Bun.file(filePath)
-    if (!(await file.exists())) return
+    if (!(await file.exists())) return []
     const text = await file.text()
-    if (!text.trim()) return
+    if (!text.trim()) return []
+    const parsedEvents: ParsedReplayEvent[] = []
     const lines = text.split("\n")
     let lastNonEmpty = -1
     for (let index = lines.length - 1; index >= 0; index -= 1) {
@@ -198,19 +244,25 @@ export class EventStore {
         if (event.v !== STORE_VERSION) {
           console.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
           await this.clearStorage()
-          return
+          return []
         }
-        this.applyEvent(event as StoreEvent)
+        parsedEvents.push({
+          event: event as StoreEvent,
+          sourceIndex,
+          lineIndex: index,
+        })
       } catch (error) {
         if (index === lastNonEmpty) {
           console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
-          return
+          return parsedEvents
         }
         console.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, error)
         await this.clearStorage()
-        return
+        return []
       }
     }
+    return parsedEvents
   }
   private applyEvent(event: StoreEvent) {
@@ -459,14 +511,18 @@ export class EventStore {
     now?: number
     maxAgeMs?: number
     activeChatIds?: Iterable<string>
+    protectedChatIds?: Iterable<string>
   }) {
     const now = args?.now ?? Date.now()
     const maxAgeMs = args?.maxAgeMs ?? STALE_EMPTY_CHAT_MAX_AGE_MS
-    const activeChatIds = new Set(args?.activeChatIds ?? [])
+    const protectedChatIds = new Set([
+      ...(args?.activeChatIds ?? []),
+      ...(args?.protectedChatIds ?? []),
+    ])
     const prunedChatIds: string[] = []
     for (const chat of this.state.chatsById.values()) {
-      if (chat.deletedAt || activeChatIds.has(chat.id)) continue
+      if (chat.deletedAt || protectedChatIds.has(chat.id)) continue
       if (now - chat.createdAt < maxAgeMs) continue
       if (this.getMessages(chat.id).length > 0) continue

package/src/server/ws-router.test.ts CHANGED Viewed

@@ -8,6 +8,7 @@ class FakeWebSocket {
   readonly sent: unknown[] = []
   readonly data = {
     subscriptions: new Map(),
+    protectedDraftChatIds: new Set<string>(),
   }
   send(message: string) {
@@ -742,6 +743,85 @@ describe("ws-router", () => {
     })
   })
+  test("protects draft-bearing chats from stale pruning before sidebar snapshots", async () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-stale", {
+      id: "chat-stale",
+      projectId: "project-1",
+      title: "New Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      unread: false,
+      provider: null,
+      planMode: false,
+      sessionToken: null,
+      lastTurnOutcome: null,
+    })
+    let capturedProtectedChatIds: string[] = []
+    const router = createWsRouter({
+      store: {
+        state,
+        async pruneStaleEmptyChats(args?: { protectedChatIds?: Iterable<string> }) {
+          capturedProtectedChatIds = [...(args?.protectedChatIds ?? [])]
+          return []
+        },
+      } as never,
+      agent: { getActiveStatuses: () => new Map(), getDrainingChatIds: () => new Set() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
+      keybindings: {
+        getSnapshot: () => DEFAULT_KEYBINDINGS_SNAPSHOT,
+        onChange: () => () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+      updateManager: null,
+    })
+    const ws = new FakeWebSocket()
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "draft-protection-1",
+        command: {
+          type: "chat.setDraftProtection",
+          chatIds: ["chat-stale"],
+        },
+      })
+    )
+    await router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "subscribe",
+        id: "sidebar-sub-1",
+        topic: { type: "sidebar" },
+      })
+    )
+    expect(capturedProtectedChatIds).toEqual(["chat-stale"])
+    expect(ws.sent[0]).toEqual({
+      v: PROTOCOL_VERSION,
+      type: "ack",
+      id: "draft-protection-1",
+    })
+  })
   test("broadcasts background title-generation errors to connected clients", () => {
     let reportBackgroundError: ((message: string) => void) | null | undefined
     const router = createWsRouter({

package/src/server/ws-router.ts CHANGED Viewed

@@ -18,6 +18,7 @@ const DEFAULT_CHAT_RECENT_LIMIT = 200
 export interface ClientState {
   subscriptions: Map<string, SubscriptionTopic>
   snapshotSignatures: Map<string, string>
+  protectedDraftChatIds?: Set<string>
 }
 interface CreateWsRouterArgs {
@@ -57,7 +58,7 @@ export function createWsRouter({
 }: CreateWsRouterArgs) {
   const sockets = new Set<ServerWebSocket<ClientState>>()
   const resolvedDiffStore = diffStore ?? {
-    getProjectSnapshot: () => ({ status: "unknown", branchName: undefined, defaultBranchName: undefined, originRepoSlug: undefined, hasUpstream: undefined, aheadCount: undefined, behindCount: undefined, lastFetchedAt: undefined, files: [] as const, branchHistory: { entries: [] as const } }),
+    getProjectSnapshot: () => ({ status: "unknown", branchName: undefined, defaultBranchName: undefined, hasOriginRemote: undefined, originRepoSlug: undefined, hasUpstream: undefined, aheadCount: undefined, behindCount: undefined, lastFetchedAt: undefined, files: [] as const, branchHistory: { entries: [] as const } }),
     refreshSnapshot: async () => false,
     initializeGit: async () => ({ ok: true, branchName: undefined, snapshotChanged: false }),
     getGitHubPublishInfo: async () => ({ ghInstalled: false, authenticated: false, activeAccountLogin: undefined, owners: [], suggestedRepoName: "my-repo" }),
@@ -83,9 +84,28 @@ export function createWsRouter({
     ])
   }
-  async function maybePruneStaleEmptyChats() {
+  function getProtectedDraftChatIds(extraSockets?: Iterable<ServerWebSocket<ClientState>>) {
+    const protectedChatIds = new Set<string>()
+    for (const socket of sockets) {
+      for (const chatId of socket.data.protectedDraftChatIds ?? []) {
+        protectedChatIds.add(chatId)
+      }
+    }
+    for (const socket of extraSockets ?? []) {
+      for (const chatId of socket.data.protectedDraftChatIds ?? []) {
+        protectedChatIds.add(chatId)
+      }
+    }
+    return protectedChatIds
+  }
+  async function maybePruneStaleEmptyChats(extraSockets?: Iterable<ServerWebSocket<ClientState>>) {
     await store.pruneStaleEmptyChats?.({
       activeChatIds: getProtectedChatIds(),
+      protectedChatIds: getProtectedDraftChatIds(extraSockets),
     })
   }
@@ -194,7 +214,7 @@ export function createWsRouter({
   async function pushSnapshots(ws: ServerWebSocket<ClientState>, options?: { skipPrune?: boolean }) {
     if (!options?.skipPrune) {
-      await maybePruneStaleEmptyChats()
+      await maybePruneStaleEmptyChats([ws])
     }
     const snapshotSignatures = ensureSnapshotSignatures(ws)
     for (const [id, topic] of ws.data.subscriptions.entries()) {
@@ -410,6 +430,11 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
         }
+        case "chat.setDraftProtection": {
+          ws.data.protectedDraftChatIds = new Set(command.chatIds)
+          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 })

package/src/shared/protocol.ts CHANGED Viewed

@@ -67,6 +67,7 @@ export type ClientCommand =
   | { type: "chat.create"; projectId: string }
   | { type: "chat.rename"; chatId: string; title: string }
   | { type: "chat.delete"; chatId: string }
+  | { type: "chat.setDraftProtection"; chatIds: string[] }
   | { type: "chat.markRead"; chatId: string }
   | {
       type: "chat.send"

package/src/shared/types.ts CHANGED Viewed

@@ -544,6 +544,7 @@ export interface GitHubRepoAvailabilityResult {
 export interface BranchMetadata {
   branchName?: string
   defaultBranchName?: string
+  hasOriginRemote?: boolean
   originRepoSlug?: string
   hasUpstream?: boolean
 }