@cuongtran001/kanna 0.39.2

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

@@ -0,0 +1,315 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test"
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+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
+
+let tempProjectPath = ""
+let tempHomePath = ""
+const originalHome = process.env.HOME
+const originalZdotdir = process.env.ZDOTDIR
+const originalHistfile = process.env.HISTFILE
+
+beforeAll(async () => {
+  if (!isSupportedPlatform) return
+  tempProjectPath = await mkdtemp(path.join(os.tmpdir(), "kanna-terminal-manager-"))
+  tempHomePath = await mkdtemp(path.join(os.tmpdir(), "kanna-terminal-home-"))
+  await mkdir(path.join(tempHomePath, ".config"), { recursive: true })
+  // Create a minimal .zshrc to prevent the zsh-newuser-install interactive dialog
+  // from running on first login (which would intercept test input).
+  await writeFile(path.join(tempHomePath, ".zshrc"), "# minimal test config\n", "utf8")
+  process.env.HOME = tempHomePath
+  process.env.ZDOTDIR = tempHomePath
+  process.env.HISTFILE = path.join(tempHomePath, ".zsh_history")
+})
+
+afterEach(async () => {
+  if (!tempProjectPath) return
+  await rm(tempProjectPath, { recursive: true, force: true })
+  tempProjectPath = await mkdtemp(path.join(os.tmpdir(), "kanna-terminal-manager-"))
+})
+
+afterAll(async () => {
+  if (originalHome === undefined) {
+    delete process.env.HOME
+  } else {
+    process.env.HOME = originalHome
+  }
+
+  if (originalZdotdir === undefined) {
+    delete process.env.ZDOTDIR
+  } else {
+    process.env.ZDOTDIR = originalZdotdir
+  }
+
+  if (originalHistfile === undefined) {
+    delete process.env.HISTFILE
+  } else {
+    process.env.HISTFILE = originalHistfile
+  }
+
+  if (tempHomePath) {
+    await rm(tempHomePath, { recursive: true, force: true })
+  }
+})
+
+async function waitFor(check: () => boolean, timeoutMs: number, intervalMs = 25) {
+  const startedAt = Date.now()
+  while (Date.now() - startedAt < timeoutMs) {
+    if (check()) return
+    await Bun.sleep(intervalMs)
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms`)
+}
+
+async function createSession(terminalId: string) {
+  const manager = new TerminalManager()
+  let output = ""
+  manager.onEvent((event) => {
+    if (event.type === "terminal.output" && event.terminalId === terminalId) {
+      output += event.data
+    }
+  })
+
+  manager.createTerminal({
+    projectPath: tempProjectPath,
+    terminalId,
+    cols: 80,
+    rows: 24,
+    scrollback: 1_000,
+  })
+
+  manager.write(terminalId, "printf '__KANNA_READY__\\n'\r")
+  // Wait for the actual command output (the bare string on its own line: __KANNA_READY__\r\n)
+  // rather than the terminal echo of the input (which also contains __KANNA_READY__ inside quotes).
+  await waitFor(() => output.includes("__KANNA_READY__\r\n"), SHELL_START_TIMEOUT_MS)
+
+  return {
+    manager,
+    getOutput: () => output,
+  }
+}
+
+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"
+    const { manager, getOutput } = await createSession(terminalId)
+
+    try {
+      manager.write(terminalId, `python3 -c "import time; print('__KANNA_SLEEP__', flush=True); time.sleep(30)"\r`)
+      await waitFor(() => getOutput().includes("__KANNA_SLEEP__"), COMMAND_TIMEOUT_MS)
+
+      manager.write(terminalId, "\x03")
+      manager.write(terminalId, "printf '__KANNA_AFTER_INT__\\n'\r")
+
+      await waitFor(() => getOutput().includes("__KANNA_AFTER_INT__"), COMMAND_TIMEOUT_MS)
+
+      const snapshot = manager.getSnapshot(terminalId)
+      expect(snapshot?.status).toBe("running")
+      expect(getOutput()).toContain("__KANNA_AFTER_INT__")
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+
+  test("ctrl+c at an idle prompt does not exit the shell", async () => {
+    const terminalId = "terminal-ctrl-c-prompt"
+    const { manager, getOutput } = await createSession(terminalId)
+
+    try {
+      const before = getOutput()
+      manager.write(terminalId, "\x03")
+
+      await waitFor(() => getOutput().length > before.length, COMMAND_TIMEOUT_MS)
+
+      const snapshot = manager.getSnapshot(terminalId)
+      expect(snapshot?.status).toBe("running")
+      expect(getOutput().length).toBeGreaterThan(before.length)
+    } finally {
+      manager.close(terminalId)
+    }
+  })
+
+  test("ctrl+d preserves eof behavior", async () => {
+    const terminalId = "terminal-ctrl-d"
+    const { manager } = await createSession(terminalId)
+
+    try {
+      manager.write(terminalId, "\x04")
+
+      await waitFor(() => manager.getSnapshot(terminalId)?.status === "exited", COMMAND_TIMEOUT_MS)
+
+      expect(manager.getSnapshot(terminalId)?.exitCode).toBe(0)
+    } finally {
+      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

@@ -0,0 +1,350 @@
+import path from "node:path"
+import process from "node:process"
+import defaultShell, { detectDefaultShell } from "default-shell"
+import { Terminal } from "@xterm/headless"
+import { SerializeAddon } from "@xterm/addon-serialize"
+import type { TerminalEvent, TerminalSnapshot } from "../shared/protocol"
+
+const DEFAULT_COLS = 80
+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
+  terminalId: string
+  cols: number
+  rows: number
+  scrollback: number
+}
+
+interface TerminalSession {
+  terminalId: string
+  title: string
+  cwd: string
+  shell: string
+  cols: number
+  rows: number
+  scrollback: number
+  status: "running" | "exited"
+  exitCode: number | null
+  process: Bun.Subprocess | null
+  terminal: Bun.Terminal
+  headless: Terminal
+  serializeAddon: SerializeAddon
+  focusReportingEnabled: boolean
+  modeSequenceTail: string
+}
+
+function clampScrollback(value: number) {
+  if (!Number.isFinite(value)) return DEFAULT_SCROLLBACK
+  return Math.min(MAX_SCROLLBACK, Math.max(MIN_SCROLLBACK, Math.round(value)))
+}
+
+function normalizeTerminalDimension(value: number, fallback: number) {
+  if (!Number.isFinite(value)) return fallback
+  return Math.max(1, Math.round(value))
+}
+
+function resolveShell() {
+  try {
+    return detectDefaultShell()
+  } catch {
+    if (defaultShell) return defaultShell
+    if (process.platform === "win32") {
+      return process.env.ComSpec || "cmd.exe"
+    }
+    return process.env.SHELL || "/bin/sh"
+  }
+}
+
+function resolveShellArgs(shellPath: string) {
+  if (process.platform === "win32") {
+    return []
+  }
+
+  const shellName = path.basename(shellPath)
+  if (["bash", "zsh", "fish", "sh", "ksh"].includes(shellName)) {
+    return ["-l"]
+  }
+
+  return []
+}
+
+function createTerminalEnv() {
+  return {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+  }
+}
+
+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) {
+    return data
+  }
+
+  return data.replaceAll(FOCUS_IN_SEQUENCE, "").replaceAll(FOCUS_OUT_SEQUENCE, "")
+}
+
+function killTerminalProcessTree(subprocess: Bun.Subprocess | null) {
+  if (!subprocess) return
+
+  const pid = subprocess.pid
+  if (typeof pid !== "number") return
+
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, "SIGKILL")
+      return
+    } catch {
+      // Fall back to killing only the shell process if group termination fails.
+    }
+  }
+
+  try {
+    subprocess.kill("SIGKILL")
+  } catch {
+    // Ignore subprocess shutdown errors during disposal.
+  }
+}
+
+function signalTerminalProcessGroup(subprocess: Bun.Subprocess | null, signal: NodeJS.Signals) {
+  if (!subprocess) return false
+
+  const pid = subprocess.pid
+  if (typeof pid !== "number") return false
+
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal)
+      return true
+    } catch {
+      // Fall back to signaling only the shell if group signaling fails.
+    }
+  }
+
+  try {
+    subprocess.kill(signal)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export class TerminalManager {
+  private readonly sessions = new Map<string, TerminalSession>()
+  private readonly listeners = new Set<(event: TerminalEvent) => void>()
+
+  onEvent(listener: (event: TerminalEvent) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  createTerminal(args: CreateTerminalArgs) {
+    if (process.platform === "win32") {
+      throw new Error("Embedded terminal is currently supported on macOS/Linux only.")
+    }
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Embedded terminal requires Bun 1.3.5+ with Bun.Terminal support.")
+    }
+
+    const existing = this.sessions.get(args.terminalId)
+    if (existing) {
+      existing.scrollback = clampScrollback(args.scrollback)
+      existing.cols = normalizeTerminalDimension(args.cols, existing.cols)
+      existing.rows = normalizeTerminalDimension(args.rows, existing.rows)
+      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)
+    }
+
+    const shell = resolveShell()
+    const cols = normalizeTerminalDimension(args.cols, DEFAULT_COLS)
+    const rows = normalizeTerminalDimension(args.rows, DEFAULT_ROWS)
+    const scrollback = clampScrollback(args.scrollback)
+    const title = path.basename(shell) || "shell"
+    const headless = new Terminal({ cols, rows, scrollback, allowProposedApi: true })
+    const serializeAddon = new SerializeAddon()
+    headless.loadAddon(serializeAddon)
+
+    const session: TerminalSession = {
+      terminalId: args.terminalId,
+      title,
+      cwd: args.projectPath,
+      shell,
+      cols,
+      rows,
+      scrollback,
+      status: "running",
+      exitCode: null,
+      process: null,
+      terminal: new Bun.Terminal({
+        cols,
+        rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => {
+          const chunk = Buffer.from(data).toString("utf8")
+          updateFocusReportingState(session, chunk)
+          headless.write(chunk)
+          this.emit({
+            type: "terminal.output",
+            terminalId: args.terminalId,
+            data: chunk,
+          })
+        },
+      }),
+      headless,
+      serializeAddon,
+      focusReportingEnabled: false,
+      modeSequenceTail: "",
+    }
+
+    try {
+      session.process = Bun.spawn([shell, ...resolveShellArgs(shell)], {
+        cwd: args.projectPath,
+        env: createTerminalEnv(),
+        terminal: session.terminal,
+      })
+    } catch (error) {
+      session.terminal.close()
+      session.serializeAddon.dispose()
+      session.headless.dispose()
+      throw error
+    }
+    void session.process.exited.then((exitCode) => {
+      const active = this.sessions.get(args.terminalId)
+      if (!active) return
+      active.status = "exited"
+      active.exitCode = exitCode
+      this.emit({
+        type: "terminal.exit",
+        terminalId: args.terminalId,
+        exitCode,
+      })
+    }).catch((error) => {
+      const active = this.sessions.get(args.terminalId)
+      if (!active) return
+      active.status = "exited"
+      active.exitCode = 1
+      this.emit({
+        type: "terminal.output",
+        terminalId: args.terminalId,
+        data: `\r\n[terminal error] ${error instanceof Error ? error.message : String(error)}\r\n`,
+      })
+      this.emit({
+        type: "terminal.exit",
+        terminalId: args.terminalId,
+        exitCode: 1,
+      })
+    })
+
+    this.sessions.set(args.terminalId, session)
+    return this.snapshotOf(session)
+  }
+
+  getSnapshot(terminalId: string): TerminalSnapshot | null {
+    const session = this.sessions.get(terminalId)
+    return session ? this.snapshotOf(session) : null
+  }
+
+  write(terminalId: string, data: string) {
+    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 < filteredData.length) {
+      const ctrlCIndex = filteredData.indexOf("\x03", cursor)
+
+      if (ctrlCIndex === -1) {
+        session.terminal.write(filteredData.slice(cursor))
+        return
+      }
+
+      if (ctrlCIndex > cursor) {
+        session.terminal.write(filteredData.slice(cursor, ctrlCIndex))
+      }
+
+      signalTerminalProcessGroup(session.process, "SIGINT")
+      cursor = ctrlCIndex + 1
+    }
+  }
+
+  resize(terminalId: string, cols: number, rows: number) {
+    const session = this.sessions.get(terminalId)
+    if (!session) return
+    session.cols = normalizeTerminalDimension(cols, session.cols)
+    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) {
+    const session = this.sessions.get(terminalId)
+    if (!session) return
+
+    this.sessions.delete(terminalId)
+    killTerminalProcessTree(session.process)
+    session.terminal.close()
+    session.serializeAddon.dispose()
+    session.headless.dispose()
+  }
+
+  closeByCwd(cwd: string) {
+    for (const [terminalId, session] of this.sessions.entries()) {
+      if (session.cwd !== cwd) continue
+      this.close(terminalId)
+    }
+  }
+
+  closeAll() {
+    for (const terminalId of this.sessions.keys()) {
+      this.close(terminalId)
+    }
+  }
+
+  private snapshotOf(session: TerminalSession): TerminalSnapshot {
+    return {
+      terminalId: session.terminalId,
+      title: session.title,
+      cwd: session.cwd,
+      shell: session.shell,
+      cols: session.cols,
+      rows: session.rows,
+      scrollback: session.scrollback,
+      serializedState: session.serializeAddon.serialize({ scrollback: session.scrollback }),
+      status: session.status,
+      exitCode: session.exitCode,
+    }
+  }
+
+  private emit(event: TerminalEvent) {
+    for (const listener of this.listeners) {
+      listener(event)
+    }
+  }
+}

package/src/server/test-helpers/async-event-queue.ts

@@ -0,0 +1,52 @@
+/** Async iterable queue used in tests to feed events into a session stream. */
+export class AsyncEventQueue<T> implements AsyncIterable<T> {
+  private readonly values: T[] = []
+  private readonly waiters: Array<{ resolve: (result: IteratorResult<T>) => void; reject: (error: unknown) => void }> = []
+  private closed = false
+  private pendingError: unknown = null
+
+  push(value: T): void {
+    const waiter = this.waiters.shift()
+    if (waiter) {
+      waiter.resolve({ done: false, value })
+      return
+    }
+    this.values.push(value)
+  }
+
+  throw(error: unknown): void {
+    this.pendingError = error
+    const waiter = this.waiters.shift()
+    if (waiter) {
+      waiter.reject(error)
+    }
+  }
+
+  close(): void {
+    this.closed = true
+    while (this.waiters.length > 0) {
+      this.waiters.shift()?.resolve({ done: true, value: undefined as never })
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return {
+      next: async () => {
+        if (this.pendingError !== null) {
+          const err = this.pendingError
+          this.pendingError = null
+          throw err
+        }
+        if (this.values.length > 0) {
+          return { done: false, value: this.values.shift() as T }
+        }
+        if (this.closed) {
+          return { done: true, value: undefined as never }
+        }
+        return await new Promise<IteratorResult<T>>((resolve, reject) => {
+          this.waiters.push({ resolve, reject })
+        })
+      },
+    }
+  }
+}