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

kanna-code 0.6.0 → 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 +162 -0
package/src/server/terminal-manager.ts +36 -5
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-DPinj1Li.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-DPinj1Li.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.0",
+  "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

@@ -6,6 +6,8 @@ import { TerminalManager } from "./terminal-manager"
 const SHELL_START_TIMEOUT_MS = 5_000
 const COMMAND_TIMEOUT_MS = 5_000
+const FOCUS_IN_SEQUENCE = "\x1b[I"
+const RAW_READ_HEX_COMMAND = `python3 -c "exec('import os,sys,tty,termios,select\\nfd=sys.stdin.fileno()\\nold=termios.tcgetattr(fd)\\ntty.setraw(fd)\\ntry:\\n    sys.stdout.write(\"__RAW_READY__\\\\n\")\\n    sys.stdout.flush()\\n    r,_,_=select.select([fd],[],[],1)\\n    data=os.read(fd,8) if r else b\"\"\\n    print(data.hex() or \"__EMPTY__\")\\nfinally:\\n    termios.tcsetattr(fd, termios.TCSADRAIN, old)')"\r`
 const isSupportedPlatform = process.platform !== "win32" && typeof Bun.Terminal === "function"
 const describeIfSupported = isSupportedPlatform ? describe : describe.skip
@@ -58,6 +60,10 @@ async function createSession(terminalId: string) {
   }
 }
+async function waitForOutputToContain(getOutput: () => string, value: string, timeoutMs = COMMAND_TIMEOUT_MS) {
+  await waitFor(() => getOutput().includes(value), timeoutMs)
+}
 describeIfSupported("TerminalManager", () => {
   test("ctrl+c interrupts the foreground job and keeps the shell alive", async () => {
     const terminalId = "terminal-ctrl-c-foreground"
@@ -112,4 +118,160 @@ describeIfSupported("TerminalManager", () => {
       manager.close(terminalId)
     }
   })
+  test("filters leaked focus reports while focus mode is disabled", async () => {
+    const terminalId = "terminal-focus-filtered"
+    const { manager, getOutput } = await createSession(terminalId)
+    try {
+      const beforeLength = getOutput().length
+      manager.write(terminalId, RAW_READ_HEX_COMMAND)
+      await waitForOutputToContain(getOutput, "__RAW_READY__")
+      manager.write(terminalId, FOCUS_IN_SEQUENCE)
+      await waitForOutputToContain(getOutput, "__EMPTY__")
+      const interactionOutput = getOutput().slice(beforeLength)
+      expect(interactionOutput).toContain("__EMPTY__")
+      expect(interactionOutput).not.toContain("1b5b49")
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+  test("forwards focus reports when the session mode is enabled", () => {
+    const manager = new TerminalManager() as unknown as {
+      sessions: Map<
+        string,
+        {
+          status: "running" | "exited"
+          focusReportingEnabled: boolean
+          terminal: { write: (data: string) => void }
+          process: Bun.Subprocess | null
+        }
+      >
+      write: (terminalId: string, data: string) => void
+    }
+    const writes: string[] = []
+    manager.sessions.set("terminal-focus-forwarded", {
+      status: "running",
+      focusReportingEnabled: true,
+      terminal: {
+        write(data: string) {
+          writes.push(data)
+        },
+      },
+      process: null,
+    })
+    manager.write("terminal-focus-forwarded", FOCUS_IN_SEQUENCE)
+    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"
+    const secondTerminalId = "terminal-focus-second"
+    let outputByTerminalId = new Map<string, string>()
+    manager.onEvent((event) => {
+      if (event.type !== "terminal.output") return
+      outputByTerminalId.set(event.terminalId, `${outputByTerminalId.get(event.terminalId) ?? ""}${event.data}`)
+    })
+    const getOutput = (terminalId: string) => outputByTerminalId.get(terminalId) ?? ""
+    const createManagedSession = async (terminalId: string) => {
+      manager.createTerminal({
+        projectPath: tempProjectPath,
+        terminalId,
+        cols: 80,
+        rows: 24,
+        scrollback: 1_000,
+      })
+      manager.write(terminalId, "printf '__KANNA_READY__\\n'\r")
+      await waitForOutputToContain(() => getOutput(terminalId), "__KANNA_READY__", SHELL_START_TIMEOUT_MS)
+    }
+    try {
+      await createManagedSession(firstTerminalId)
+      const firstBeforeLength = getOutput(firstTerminalId).length
+      manager.write(firstTerminalId, "printf '\\033[?1004h'\r")
+      await waitFor(() => getOutput(firstTerminalId).length > firstBeforeLength, COMMAND_TIMEOUT_MS)
+      manager.close(firstTerminalId)
+      await createManagedSession(secondTerminalId)
+      const before = getOutput(secondTerminalId).length
+      manager.write(secondTerminalId, "cat -v\r")
+      await waitFor(() => getOutput(secondTerminalId).length > before, COMMAND_TIMEOUT_MS)
+      manager.write(secondTerminalId, FOCUS_IN_SEQUENCE)
+      manager.write(secondTerminalId, "\x03")
+      manager.write(secondTerminalId, "printf '__KANNA_FRESH_SESSION__\\n'\r")
+      await waitForOutputToContain(() => getOutput(secondTerminalId), "__KANNA_FRESH_SESSION__")
+      const interactionOutput = getOutput(secondTerminalId).slice(before)
+      expect(interactionOutput).not.toContain("^[[I")
+    } finally {
+      manager.close(firstTerminalId)
+      manager.close(secondTerminalId)
+    }
+  })
 })

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

@@ -10,6 +10,9 @@ const DEFAULT_ROWS = 24
 const DEFAULT_SCROLLBACK = 1_000
 const MIN_SCROLLBACK = 500
 const MAX_SCROLLBACK = 5_000
+const FOCUS_IN_SEQUENCE = "\x1b[I"
+const FOCUS_OUT_SEQUENCE = "\x1b[O"
+const MODE_SEQUENCE_TAIL_LENGTH = 16
 interface CreateTerminalArgs {
   projectPath: string
@@ -33,6 +36,8 @@ interface TerminalSession {
   terminal: Bun.Terminal
   headless: Terminal
   serializeAddon: SerializeAddon
+  focusReportingEnabled: boolean
+  modeSequenceTail: string
 }
 function clampScrollback(value: number) {
@@ -78,6 +83,25 @@ function createTerminalEnv() {
   }
 }
+function updateFocusReportingState(session: Pick<TerminalSession, "focusReportingEnabled" | "modeSequenceTail">, chunk: string) {
+  const combined = session.modeSequenceTail + chunk
+  const regex = /\x1b\[\?1004([hl])/g
+  for (const match of combined.matchAll(regex)) {
+    session.focusReportingEnabled = match[1] === "h"
+  }
+  session.modeSequenceTail = combined.slice(-MODE_SEQUENCE_TAIL_LENGTH)
+}
+function filterFocusReportInput(data: string, allowFocusReporting: boolean) {
+  if (allowFocusReporting || (!data.includes(FOCUS_IN_SEQUENCE) && !data.includes(FOCUS_OUT_SEQUENCE))) {
+    return data
+  }
+  return data.replaceAll(FOCUS_IN_SEQUENCE, "").replaceAll(FOCUS_OUT_SEQUENCE, "")
+}
 function killTerminalProcessTree(subprocess: Bun.Subprocess | null) {
   if (!subprocess) return
@@ -150,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)
     }
@@ -179,6 +204,7 @@ export class TerminalManager {
         name: "xterm-256color",
         data: (_terminal, data) => {
           const chunk = Buffer.from(data).toString("utf8")
+          updateFocusReportingState(session, chunk)
           headless.write(chunk)
           this.emit({
             type: "terminal.output",
@@ -189,6 +215,8 @@ export class TerminalManager {
       }),
       headless,
       serializeAddon,
+      focusReportingEnabled: false,
+      modeSequenceTail: "",
     }
     try {
@@ -203,7 +231,6 @@ export class TerminalManager {
       session.headless.dispose()
       throw error
     }
     void session.process.exited.then((exitCode) => {
       const active = this.sessions.get(args.terminalId)
       if (!active) return
@@ -244,18 +271,21 @@ export class TerminalManager {
     const session = this.sessions.get(terminalId)
     if (!session || session.status === "exited") return
+    const filteredData = filterFocusReportInput(data, session.focusReportingEnabled)
+    if (!filteredData) return
     let cursor = 0
-    while (cursor < data.length) {
-      const ctrlCIndex = data.indexOf("\x03", cursor)
+    while (cursor < filteredData.length) {
+      const ctrlCIndex = filteredData.indexOf("\x03", cursor)
       if (ctrlCIndex === -1) {
-        session.terminal.write(data.slice(cursor))
+        session.terminal.write(filteredData.slice(cursor))
         return
       }
       if (ctrlCIndex > cursor) {
-        session.terminal.write(data.slice(cursor, ctrlCIndex))
+        session.terminal.write(filteredData.slice(cursor, ctrlCIndex))
       }
       signalTerminalProcessGroup(session.process, "SIGINT")
@@ -270,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
         }