npm - kanna-code - Versions diffs - 0.3.0 → 0.4.1 - Mend

kanna-code 0.3.0 → 0.4.1

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 (21) hide show

package/dist/client/assets/index-BXpHm8Wa.css +1 -0
package/dist/client/assets/index-CcZLosQ7.js +419 -0
package/dist/client/index.html +2 -2
package/package.json +3 -2
package/src/server/agent.test.ts +170 -0
package/src/server/agent.ts +32 -0
package/src/server/cli-runtime.test.ts +188 -0
package/src/server/cli-runtime.ts +274 -0
package/src/server/cli.ts +20 -127
package/src/server/codex-app-server.test.ts +186 -0
package/src/server/codex-app-server.ts +17 -2
package/src/server/discovery.ts +0 -39
package/src/server/server.ts +3 -1
package/src/server/ws-router.test.ts +47 -0
package/src/server/ws-router.ts +4 -0
package/src/shared/protocol.ts +1 -0
package/src/shared/tools.test.ts +12 -1
package/src/shared/tools.ts +19 -1
package/src/shared/types.ts +5 -1
package/dist/client/assets/index-Byzgv_-q.js +0 -409
package/dist/client/assets/index-gld9RxCU.css +0 -1

package/dist/client/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <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-Byzgv_-q.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-gld9RxCU.css">
+    <script type="module" crossorigin src="/assets/index-CcZLosQ7.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BXpHm8Wa.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "kanna-code",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A beautiful web UI for Claude Code",
   "license": "MIT",
   "keywords": [
@@ -42,7 +42,8 @@
     "prepublishOnly": "vite build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.39"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.39",
+    "@radix-ui/react-context-menu": "^2.2.16"
   },
   "devDependencies": {
     "@dnd-kit/core": "^6.3.1",

package/src/server/agent.test.ts CHANGED Viewed

@@ -481,6 +481,176 @@ describe("AgentCoordinator codex integration", () => {
     expect(store.messages.some((entry) => entry.kind === "context_cleared")).toBe(true)
     expect(store.chat.sessionToken).toBe("thread-2")
   })
+  test("cancelling a waiting ask-user-question records a discarded tool result", async () => {
+    let releaseInterrupt!: () => void
+    const interrupted = new Promise<void>((resolve) => {
+      releaseInterrupt = resolve
+    })
+    const fakeCodexManager = {
+      async startSession() {},
+      async startTurn(args: {
+        onToolRequest: (request: any) => Promise<unknown>
+      }): Promise<HarnessTurn> {
+        async function* stream() {
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "system_init",
+              provider: "codex",
+              model: "gpt-5.4",
+              tools: [],
+              agents: [],
+              slashCommands: [],
+              mcpServers: [],
+            }),
+          }
+          void args.onToolRequest({
+            tool: {
+              kind: "tool",
+              toolKind: "ask_user_question",
+              toolName: "AskUserQuestion",
+              toolId: "question-1",
+              input: {
+                questions: [{ question: "Provider?" }],
+              },
+            },
+          })
+          await interrupted
+        }
+        return {
+          provider: "codex",
+          stream: stream(),
+          interrupt: async () => {
+            releaseInterrupt()
+          },
+          close: () => {},
+        }
+      },
+    }
+    const store = createFakeStore()
+    const coordinator = new AgentCoordinator({
+      store: store as never,
+      onStateChange: () => {},
+      codexManager: fakeCodexManager as never,
+    })
+    await coordinator.send({
+      type: "chat.send",
+      chatId: "chat-1",
+      provider: "codex",
+      content: "ask me something",
+    })
+    await waitFor(() => coordinator.getPendingTool("chat-1")?.toolKind === "ask_user_question")
+    await coordinator.cancel("chat-1")
+    const discardedResult = store.messages.find((entry) => entry.kind === "tool_result" && entry.toolId === "question-1")
+    expect(discardedResult).toBeDefined()
+    if (!discardedResult || discardedResult.kind !== "tool_result") {
+      throw new Error("missing discarded ask-user-question result")
+    }
+    expect(discardedResult.content).toEqual({ discarded: true, answers: {} })
+    expect(store.messages.some((entry) => entry.kind === "interrupted")).toBe(true)
+  })
+  test("cancelling a waiting codex exit-plan prompt discards it without starting a follow-up turn", async () => {
+    let releaseInterrupt!: () => void
+    const interrupted = new Promise<void>((resolve) => {
+      releaseInterrupt = resolve
+    })
+    const startTurnCalls: string[] = []
+    const fakeCodexManager = {
+      async startSession() {},
+      async startTurn(args: {
+        content: string
+        onToolRequest: (request: any) => Promise<unknown>
+      }): Promise<HarnessTurn> {
+        startTurnCalls.push(args.content)
+        async function* stream() {
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "system_init",
+              provider: "codex",
+              model: "gpt-5.4",
+              tools: [],
+              agents: [],
+              slashCommands: [],
+              mcpServers: [],
+            }),
+          }
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "tool_call",
+              tool: {
+                kind: "tool",
+                toolKind: "exit_plan_mode",
+                toolName: "ExitPlanMode",
+                toolId: "exit-1",
+                input: {
+                  plan: "## Plan",
+                },
+              },
+            }),
+          }
+          await args.onToolRequest({
+            tool: {
+              kind: "tool",
+              toolKind: "exit_plan_mode",
+              toolName: "ExitPlanMode",
+              toolId: "exit-1",
+              input: {
+                plan: "## Plan",
+              },
+            },
+          })
+          await interrupted
+        }
+        return {
+          provider: "codex",
+          stream: stream(),
+          interrupt: async () => {
+            releaseInterrupt()
+          },
+          close: () => {},
+        }
+      },
+    }
+    const store = createFakeStore()
+    const coordinator = new AgentCoordinator({
+      store: store as never,
+      onStateChange: () => {},
+      codexManager: fakeCodexManager as never,
+    })
+    await coordinator.send({
+      type: "chat.send",
+      chatId: "chat-1",
+      provider: "codex",
+      content: "plan this",
+      planMode: true,
+    })
+    await waitFor(() => coordinator.getPendingTool("chat-1")?.toolKind === "exit_plan_mode")
+    await coordinator.cancel("chat-1")
+    const discardedResult = store.messages.find((entry) => entry.kind === "tool_result" && entry.toolId === "exit-1")
+    expect(discardedResult).toBeDefined()
+    if (!discardedResult || discardedResult.kind !== "tool_result") {
+      throw new Error("missing discarded exit-plan result")
+    }
+    expect(discardedResult.content).toEqual({ discarded: true })
+    expect(startTurnCalls).toEqual(["plan this"])
+  })
 })
 function createFakeStore() {

package/src/server/agent.ts CHANGED Viewed

@@ -88,6 +88,21 @@ function stringFromUnknown(value: unknown) {
   }
 }
+function discardedToolResult(
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+) {
+  if (tool.toolKind === "ask_user_question") {
+    return {
+      discarded: true,
+      answers: {},
+    }
+  }
+  return {
+    discarded: true,
+  }
+}
 export function normalizeClaudeStreamMessage(message: any): TranscriptEntry[] {
   const debugRaw = JSON.stringify(message)
   const messageId = typeof message.uuid === "string" ? message.uuid : undefined
@@ -613,8 +628,25 @@ export class AgentCoordinator {
     if (!active) return
     active.cancelRequested = true
+    const pendingTool = active.pendingTool
     active.pendingTool = null
+    if (pendingTool) {
+      const result = discardedToolResult(pendingTool.tool)
+      await this.store.appendMessage(
+        chatId,
+        timestamped({
+          kind: "tool_result",
+          toolId: pendingTool.toolUseId,
+          content: result,
+        })
+      )
+      if (active.provider === "codex" && pendingTool.tool.toolKind === "exit_plan_mode") {
+        pendingTool.resolve(result)
+      }
+    }
     await this.store.appendMessage(chatId, timestamped({ kind: "interrupted" }))
     await this.store.recordTurnCancelled(chatId)
     active.cancelRecorded = true

package/src/server/cli-runtime.test.ts ADDED Viewed

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "bun:test"
+import { compareVersions, parseArgs, runCli } from "./cli-runtime"
+function createDeps(overrides: Partial<Parameters<typeof runCli>[1]> = {}) {
+  const calls = {
+    startServer: [] as Array<{ port: number; openBrowser: boolean; strictPort: boolean }>,
+    fetchLatestVersion: [] as string[],
+    installLatest: [] as string[],
+    relaunch: [] as Array<{ command: string; args: string[] }>,
+    openUrl: [] as string[],
+    log: [] as string[],
+    warn: [] as string[],
+  }
+  const deps: Parameters<typeof runCli>[1] = {
+    version: "0.3.0",
+    startServer: async (options) => {
+      calls.startServer.push(options)
+      return {
+        port: options.port,
+        stop: async () => {},
+      }
+    },
+    fetchLatestVersion: async (packageName) => {
+      calls.fetchLatestVersion.push(packageName)
+      return "0.3.0"
+    },
+    installLatest: (packageName) => {
+      calls.installLatest.push(packageName)
+      return true
+    },
+    relaunch: (command, args) => {
+      calls.relaunch.push({ command, args })
+      return 0
+    },
+    openUrl: (url) => {
+      calls.openUrl.push(url)
+    },
+    log: (message) => {
+      calls.log.push(message)
+    },
+    warn: (message) => {
+      calls.warn.push(message)
+    },
+    ...overrides,
+  }
+  return { calls, deps }
+}
+describe("parseArgs", () => {
+  test("parses runtime options", () => {
+    expect(parseArgs(["--port", "4000", "--no-open"])).toEqual({
+      kind: "run",
+      options: {
+        port: 4000,
+        openBrowser: false,
+        strictPort: false,
+      },
+    })
+  })
+  test("parses strict port mode", () => {
+    expect(parseArgs(["--strict-port"])).toEqual({
+      kind: "run",
+      options: {
+        port: 3210,
+        openBrowser: true,
+        strictPort: true,
+      },
+    })
+  })
+  test("returns version and help actions without running startup", () => {
+    expect(parseArgs(["--version"])).toEqual({ kind: "version" })
+    expect(parseArgs(["--help"])).toEqual({ kind: "help" })
+  })
+})
+describe("compareVersions", () => {
+  test("orders semver-like versions", () => {
+    expect(compareVersions("0.3.0", "0.3.0")).toBe(0)
+    expect(compareVersions("0.3.0", "0.3.1")).toBe(-1)
+    expect(compareVersions("1.0.0", "0.9.9")).toBe(1)
+  })
+})
+describe("runCli", () => {
+  test("skips update checks for --version", async () => {
+    const { calls, deps } = createDeps()
+    const result = await runCli(["--version"], deps)
+    expect(result).toEqual({ kind: "exited", code: 0 })
+    expect(calls.fetchLatestVersion).toEqual([])
+    expect(calls.startServer).toEqual([])
+    expect(calls.log).toEqual(["0.3.0"])
+  })
+  test("starts normally when no newer version exists", async () => {
+    const { calls, deps } = createDeps()
+    const result = await runCli(["--port", "4000", "--no-open"], deps)
+    expect(result.kind).toBe("started")
+    expect(calls.fetchLatestVersion).toEqual(["kanna-code"])
+    expect(calls.installLatest).toEqual([])
+    expect(calls.relaunch).toEqual([])
+    expect(calls.startServer).toEqual([{ port: 4000, openBrowser: false, strictPort: false }])
+    expect(calls.openUrl).toEqual([])
+  })
+  test("opens the root route in the browser", async () => {
+    const { calls, deps } = createDeps()
+    await runCli(["--port", "4000"], deps)
+    expect(calls.openUrl).toEqual(["http://localhost:4000"])
+  })
+  test("installs and relaunches when a newer version is available", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        return "0.4.0"
+      },
+    })
+    const result = await runCli(["--port", "4000", "--no-open"], deps)
+    expect(result).toEqual({ kind: "exited", code: 0 })
+    expect(calls.installLatest).toEqual(["kanna-code"])
+    expect(calls.relaunch).toEqual([{ command: "kanna", args: ["--port", "4000", "--no-open"] }])
+    expect(calls.startServer).toEqual([])
+  })
+  test("falls back to current version when install fails", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        return "0.4.0"
+      },
+      installLatest: (packageName) => {
+        calls.installLatest.push(packageName)
+        return false
+      },
+    })
+    const result = await runCli(["--no-open"], deps)
+    expect(result.kind).toBe("started")
+    expect(calls.installLatest).toEqual(["kanna-code"])
+    expect(calls.relaunch).toEqual([])
+    expect(calls.warn).toContain("[kanna] update failed, continuing current version")
+  })
+  test("falls back to current version when the registry check fails", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        throw new Error("network unavailable")
+      },
+    })
+    const result = await runCli(["--no-open"], deps)
+    expect(result.kind).toBe("started")
+    expect(calls.installLatest).toEqual([])
+    expect(calls.relaunch).toEqual([])
+    expect(calls.warn).toContain("[kanna] update check failed, continuing current version")
+  })
+  test("preserves original argv when relaunching", async () => {
+    const { calls, deps } = createDeps({
+      fetchLatestVersion: async (packageName) => {
+        calls.fetchLatestVersion.push(packageName)
+        return "0.4.0"
+      },
+    })
+    await runCli(["--port", "4567", "--no-open"], deps)
+    expect(calls.relaunch[0]).toEqual({
+      command: "kanna",
+      args: ["--port", "4567", "--no-open"],
+    })
+  })
+})