npm - kanna-code - Versions diffs - 0.6.1 → 0.7.0 - Mend

kanna-code 0.6.1 → 0.7.0

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

package/dist/client/assets/index-BQedIo87.css +32 -0
package/dist/client/assets/index-BnsoKj0W.js +498 -0
package/dist/client/index.html +2 -2
package/package.json +2 -1
package/src/server/external-open.test.ts +60 -0
package/src/server/external-open.ts +203 -50
package/src/server/terminal-manager.test.ts +56 -22
package/src/server/terminal-manager.ts +2 -0
package/src/server/ws-router.ts +1 -1
package/src/shared/protocol.ts +15 -1
package/dist/client/assets/index-C4BaFDD7.css +0 -32
package/dist/client/assets/index-CAUb9qP0.js +0 -478

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-CAUb9qP0.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C4BaFDD7.css">
+    <script type="module" crossorigin src="/assets/index-BnsoKj0W.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BQedIo87.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "kanna-code",
   "type": "module",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A beautiful web UI for Claude Code",
   "license": "MIT",
   "keywords": [
@@ -46,6 +46,7 @@
     "@radix-ui/react-context-menu": "^2.2.16",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/addon-web-links": "^0.12.0",
     "@xterm/headless": "^6.0.0",
     "@xterm/xterm": "^6.0.0",
     "default-shell": "^2.2.0",

package/src/server/external-open.test.ts ADDED Viewed

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test"
+import { buildEditorCommand, tokenizeCommandTemplate } from "./external-open"
+describe("tokenizeCommandTemplate", () => {
+  test("keeps quoted arguments together", () => {
+    expect(tokenizeCommandTemplate('code --reuse-window "{path}"')).toEqual([
+      "code",
+      "--reuse-window",
+      "{path}",
+    ])
+  })
+})
+describe("buildEditorCommand", () => {
+  test("builds a preset goto command for file links", () => {
+    expect(
+      buildEditorCommand({
+        localPath: "/Users/jake/Projects/kanna/src/client/app/App.tsx",
+        isDirectory: false,
+        line: 12,
+        column: 3,
+        editor: { preset: "vscode", commandTemplate: "code {path}" },
+        platform: "linux",
+      })
+    ).toEqual({
+      command: "code",
+      args: ["--goto", "/Users/jake/Projects/kanna/src/client/app/App.tsx:12:3"],
+    })
+  })
+  test("builds a preset project command for directory opens", () => {
+    expect(
+      buildEditorCommand({
+        localPath: "/Users/jake/Projects/kanna",
+        isDirectory: true,
+        editor: { preset: "cursor", commandTemplate: "cursor {path}" },
+        platform: "linux",
+      })
+    ).toEqual({
+      command: "cursor",
+      args: ["/Users/jake/Projects/kanna"],
+    })
+  })
+  test("uses the custom template for editor opens", () => {
+    expect(
+      buildEditorCommand({
+        localPath: "/Users/jake/Projects/kanna/src/client/app/App.tsx",
+        isDirectory: false,
+        line: 12,
+        column: 1,
+        editor: { preset: "custom", commandTemplate: 'my-editor "{path}" --line {line}' },
+        platform: "linux",
+      })
+    ).toEqual({
+      command: "my-editor",
+      args: ["/Users/jake/Projects/kanna/src/client/app/App.tsx", "--line", "12"],
+    })
+  })
+})

package/src/server/external-open.ts CHANGED Viewed

@@ -1,44 +1,59 @@
+import { stat } from "node:fs/promises"
 import process from "node:process"
-import type { ClientCommand } from "../shared/protocol"
+import type { ClientCommand, EditorOpenSettings, EditorPreset } from "../shared/protocol"
 import { resolveLocalPath } from "./paths"
 import { canOpenMacApp, hasCommand, spawnDetached } from "./process-utils"
-type OpenExternalAction = Extract<ClientCommand, { type: "system.openExternal" }>["action"]
+type OpenExternalCommand = Extract<ClientCommand, { type: "system.openExternal" }>
-export function openExternal(localPath: string, action: OpenExternalAction) {
-  const resolvedPath = resolveLocalPath(localPath)
+interface CommandSpec {
+  command: string
+  args: string[]
+}
+const DEFAULT_EDITOR_SETTINGS: EditorOpenSettings = {
+  preset: "cursor",
+  commandTemplate: "cursor {path}",
+}
+export async function openExternal(command: OpenExternalCommand) {
+  const resolvedPath = resolveLocalPath(command.localPath)
   const platform = process.platform
+  if (command.action === "open_editor") {
+    const info = await stat(resolvedPath).catch(() => null)
+    if (!info) {
+      throw new Error(`Path not found: ${resolvedPath}`)
+    }
+    const editorCommand = buildEditorCommand({
+      localPath: resolvedPath,
+      isDirectory: info.isDirectory(),
+      line: command.line,
+      column: command.column,
+      editor: command.editor ?? DEFAULT_EDITOR_SETTINGS,
+      platform,
+    })
+    spawnDetached(editorCommand.command, editorCommand.args)
+    return
+  }
   if (platform === "darwin") {
-    if (action === "open_finder") {
+    if (command.action === "open_finder") {
       spawnDetached("open", [resolvedPath])
       return
     }
-    if (action === "open_terminal") {
+    if (command.action === "open_terminal") {
       spawnDetached("open", ["-a", "Terminal", resolvedPath])
       return
     }
-    if (action === "open_editor") {
-      if (hasCommand("cursor")) {
-        spawnDetached("cursor", [resolvedPath])
-        return
-      }
-      for (const appName of ["Cursor", "Visual Studio Code", "Windsurf"]) {
-        if (!canOpenMacApp(appName)) continue
-        spawnDetached("open", ["-a", appName, resolvedPath])
-        return
-      }
-      spawnDetached("open", [resolvedPath])
-      return
-    }
   }
   if (platform === "win32") {
-    if (action === "open_finder") {
+    if (command.action === "open_finder") {
       spawnDetached("explorer", [resolvedPath])
       return
     }
-    if (action === "open_terminal") {
+    if (command.action === "open_terminal") {
       if (hasCommand("wt")) {
         spawnDetached("wt", ["-d", resolvedPath])
         return
@@ -46,46 +61,184 @@ export function openExternal(localPath: string, action: OpenExternalAction) {
       spawnDetached("cmd", ["/c", "start", "", "cmd", "/K", `cd /d ${resolvedPath}`])
       return
     }
-    if (action === "open_editor") {
-      if (hasCommand("cursor")) {
-        spawnDetached("cursor", [resolvedPath])
-        return
-      }
-      if (hasCommand("code")) {
-        spawnDetached("code", [resolvedPath])
-        return
-      }
-      spawnDetached("explorer", [resolvedPath])
-      return
-    }
   }
-  if (action === "open_finder") {
+  if (command.action === "open_finder") {
     spawnDetached("xdg-open", [resolvedPath])
     return
   }
-  if (action === "open_terminal") {
-    for (const command of ["x-terminal-emulator", "gnome-terminal", "konsole"]) {
-      if (!hasCommand(command)) continue
-      if (command === "gnome-terminal") {
-        spawnDetached(command, ["--working-directory", resolvedPath])
-      } else if (command === "konsole") {
-        spawnDetached(command, ["--workdir", resolvedPath])
+  if (command.action === "open_terminal") {
+    for (const terminalCommand of ["x-terminal-emulator", "gnome-terminal", "konsole"]) {
+      if (!hasCommand(terminalCommand)) continue
+      if (terminalCommand === "gnome-terminal") {
+        spawnDetached(terminalCommand, ["--working-directory", resolvedPath])
+      } else if (terminalCommand === "konsole") {
+        spawnDetached(terminalCommand, ["--workdir", resolvedPath])
       } else {
-        spawnDetached(command, ["--working-directory", resolvedPath])
+        spawnDetached(terminalCommand, ["--working-directory", resolvedPath])
       }
       return
     }
     spawnDetached("xdg-open", [resolvedPath])
-    return
   }
-  if (hasCommand("cursor")) {
-    spawnDetached("cursor", [resolvedPath])
-    return
+}
+export function buildEditorCommand(args: {
+  localPath: string
+  isDirectory: boolean
+  line?: number
+  column?: number
+  editor: EditorOpenSettings
+  platform: NodeJS.Platform
+}): CommandSpec {
+  const editor = normalizeEditorSettings(args.editor)
+  if (editor.preset === "custom") {
+    return buildCustomEditorCommand({
+      commandTemplate: editor.commandTemplate,
+      localPath: args.localPath,
+      line: args.line,
+      column: args.column,
+    })
   }
-  if (hasCommand("code")) {
-    spawnDetached("code", [resolvedPath])
-    return
+  return buildPresetEditorCommand(args, editor.preset)
+}
+function buildPresetEditorCommand(
+  args: {
+    localPath: string
+    isDirectory: boolean
+    line?: number
+    column?: number
+    platform: NodeJS.Platform
+  },
+  preset: Exclude<EditorPreset, "custom">
+): CommandSpec {
+  const gotoTarget = `${args.localPath}:${args.line ?? 1}:${args.column ?? 1}`
+  const opener = resolveEditorExecutable(preset, args.platform)
+  if (args.isDirectory || !args.line) {
+    return { command: opener.command, args: [...opener.args, args.localPath] }
+  }
+  return { command: opener.command, args: [...opener.args, "--goto", gotoTarget] }
+}
+function resolveEditorExecutable(preset: Exclude<EditorPreset, "custom">, platform: NodeJS.Platform) {
+  if (preset === "cursor") {
+    if (hasCommand("cursor")) return { command: "cursor", args: [] }
+    if (platform === "darwin" && canOpenMacApp("Cursor")) return { command: "open", args: ["-a", "Cursor"] }
+  }
+  if (preset === "vscode") {
+    if (hasCommand("code")) return { command: "code", args: [] }
+    if (platform === "darwin" && canOpenMacApp("Visual Studio Code")) return { command: "open", args: ["-a", "Visual Studio Code"] }
+  }
+  if (preset === "windsurf") {
+    if (hasCommand("windsurf")) return { command: "windsurf", args: [] }
+    if (platform === "darwin" && canOpenMacApp("Windsurf")) return { command: "open", args: ["-a", "Windsurf"] }
+  }
+  if (platform === "darwin") {
+    switch (preset) {
+      case "cursor":
+        return { command: "open", args: ["-a", "Cursor"] }
+      case "vscode":
+        return { command: "open", args: ["-a", "Visual Studio Code"] }
+      case "windsurf":
+        return { command: "open", args: ["-a", "Windsurf"] }
+    }
+  }
+  return { command: preset === "vscode" ? "code" : preset, args: [] }
+}
+function buildCustomEditorCommand(args: {
+  commandTemplate: string
+  localPath: string
+  line?: number
+  column?: number
+}): CommandSpec {
+  const template = args.commandTemplate.trim()
+  if (!template.includes("{path}")) {
+    throw new Error("Custom editor command must include {path}")
+  }
+  const line = String(args.line ?? 1)
+  const column = String(args.column ?? 1)
+  const replaced = template
+    .replaceAll("{path}", args.localPath)
+    .replaceAll("{line}", line)
+    .replaceAll("{column}", column)
+  const tokens = tokenizeCommandTemplate(replaced)
+  const [command, ...commandArgs] = tokens
+  if (!command) {
+    throw new Error("Custom editor command is empty")
+  }
+  return { command, args: commandArgs }
+}
+export function tokenizeCommandTemplate(template: string) {
+  const tokens: string[] = []
+  let current = ""
+  let quote: "'" | "\"" | null = null
+  for (let index = 0; index < template.length; index += 1) {
+    const char = template[index]
+    if (char === "\\" && index + 1 < template.length) {
+      current += template[index + 1]
+      index += 1
+      continue
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null
+      } else {
+        current += char
+      }
+      continue
+    }
+    if (char === "'" || char === "\"") {
+      quote = char
+      continue
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current)
+        current = ""
+      }
+      continue
+    }
+    current += char
+  }
+  if (quote) {
+    throw new Error("Custom editor command has an unclosed quote")
+  }
+  if (current.length > 0) {
+    tokens.push(current)
+  }
+  return tokens
+}
+function normalizeEditorSettings(editor: EditorOpenSettings): EditorOpenSettings {
+  const preset = normalizeEditorPreset(editor.preset)
+  return {
+    preset,
+    commandTemplate: editor.commandTemplate.trim() || DEFAULT_EDITOR_SETTINGS.commandTemplate,
+  }
+}
+function normalizeEditorPreset(preset: EditorPreset): EditorPreset {
+  switch (preset) {
+    case "vscode":
+    case "windsurf":
+    case "custom":
+    case "cursor":
+      return preset
+    default:
+      return DEFAULT_EDITOR_SETTINGS.preset
   }
-  spawnDetached("xdg-open", [resolvedPath])
 }

package/src/server/terminal-manager.test.ts CHANGED Viewed

@@ -139,28 +139,6 @@ describeIfSupported("TerminalManager", () => {
     }
   })
-  test("tracks focus report mode after the PTY enables it", async () => {
-    const terminalId = "terminal-focus-enabled"
-    const { manager, getOutput } = await createSession(terminalId)
-    try {
-      const enableBeforeLength = getOutput().length
-      manager.write(terminalId, "printf '\\033[?1004h'\r")
-      await waitFor(() => getOutput().length > enableBeforeLength, COMMAND_TIMEOUT_MS)
-      await waitFor(
-        () =>
-          (
-            (manager as unknown as {
-              sessions: Map<string, { focusReportingEnabled: boolean }>
-            }).sessions.get(terminalId)?.focusReportingEnabled
-          ) === true,
-        COMMAND_TIMEOUT_MS
-      )
-    } finally {
-      manager.close(terminalId)
-    }
-  })
   test("forwards focus reports when the session mode is enabled", () => {
     const manager = new TerminalManager() as unknown as {
       sessions: Map<
@@ -192,6 +170,62 @@ describeIfSupported("TerminalManager", () => {
     expect(writes).toEqual([FOCUS_IN_SEQUENCE])
   })
+  test("resize signals the shell process group with SIGWINCH", () => {
+    const manager = new TerminalManager() as unknown as {
+      sessions: Map<
+        string,
+        {
+          cols: number
+          rows: number
+          headless: { resize: (cols: number, rows: number) => void }
+          terminal: { resize: (cols: number, rows: number) => void }
+          process: { pid: number } | null
+        }
+      >
+      resize: (terminalId: string, cols: number, rows: number) => void
+    }
+    const resizeCalls: Array<{ cols: number; rows: number }> = []
+    const killCalls: Array<{ pid: number; signal: NodeJS.Signals }> = []
+    const originalKill = process.kill
+    ;(process as typeof process & {
+      kill: (pid: number, signal?: NodeJS.Signals | number) => boolean
+    }).kill = ((pid: number, signal?: NodeJS.Signals | number) => {
+      if (typeof signal === "string") {
+        killCalls.push({ pid, signal })
+      }
+      return true
+    }) as typeof process.kill
+    manager.sessions.set("terminal-resize-sigwinch", {
+      cols: 80,
+      rows: 24,
+      headless: {
+        resize(cols, rows) {
+          resizeCalls.push({ cols, rows })
+        },
+      },
+      terminal: {
+        resize(cols, rows) {
+          resizeCalls.push({ cols, rows })
+        },
+      },
+      process: { pid: 4321 },
+    })
+    try {
+      manager.resize("terminal-resize-sigwinch", 120, 40)
+    } finally {
+      process.kill = originalKill
+    }
+    expect(resizeCalls).toEqual([
+      { cols: 120, rows: 40 },
+      { cols: 120, rows: 40 },
+    ])
+    expect(killCalls).toContainEqual({ pid: -4321, signal: "SIGWINCH" })
+  })
   test("new sessions reset focus mode back to filtered", async () => {
     const manager = new TerminalManager()
     const firstTerminalId = "terminal-focus-first"

package/src/server/terminal-manager.ts CHANGED Viewed

@@ -174,6 +174,7 @@ export class TerminalManager {
       existing.headless.options.scrollback = existing.scrollback
       existing.headless.resize(existing.cols, existing.rows)
       existing.terminal.resize(existing.cols, existing.rows)
+      signalTerminalProcessGroup(existing.process, "SIGWINCH")
       return this.snapshotOf(existing)
     }
@@ -299,6 +300,7 @@ export class TerminalManager {
     session.rows = normalizeTerminalDimension(rows, session.rows)
     session.headless.resize(session.cols, session.rows)
     session.terminal.resize(session.cols, session.rows)
+    signalTerminalProcessGroup(session.process, "SIGWINCH")
   }
   close(terminalId: string) {

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

@@ -162,7 +162,7 @@ export function createWsRouter({
           break
         }
         case "system.openExternal": {
-          openExternal(command.localPath, command.action)
+          await openExternal(command)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
         }

package/src/shared/protocol.ts CHANGED Viewed

@@ -1,5 +1,12 @@
 import type { AgentProvider, ChatSnapshot, LocalProjectsSnapshot, ModelOptions, SidebarData } from "./types"
+export type EditorPreset = "cursor" | "vscode" | "windsurf" | "custom"
+export interface EditorOpenSettings {
+  preset: EditorPreset
+  commandTemplate: string
+}
 export type SubscriptionTopic =
   | { type: "sidebar" }
   | { type: "local-projects" }
@@ -29,7 +36,14 @@ export type ClientCommand =
   | { type: "project.create"; localPath: string; title: string }
   | { type: "project.remove"; projectId: string }
   | { type: "system.ping" }
-  | { type: "system.openExternal"; localPath: string; action: "open_finder" | "open_terminal" | "open_editor" }
+  | {
+      type: "system.openExternal"
+      localPath: string
+      action: "open_finder" | "open_terminal" | "open_editor"
+      line?: number
+      column?: number
+      editor?: EditorOpenSettings
+    }
   | { type: "chat.create"; projectId: string }
   | { type: "chat.rename"; chatId: string; title: string }
   | { type: "chat.delete"; chatId: string }