jbs-client 0.0.1 → 0.0.3

package/src/app.tsx

@@ -1,239 +0,0 @@
-import { useEffect, useMemo, useState } from "react"
-import { useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/react"
-import { ActionMenu } from "./components/action-menu.js"
-import { LogPanel } from "./components/log-panel.js"
-import { ParamForm } from "./components/param-form.js"
-import { buildPayload, menu, validateAction } from "./protocol.js"
-import { appendLog, backToMenu, createInitialState, nextFocus, openAction, previousFocus, setConnectionStatus, updateFormValue, updateSelectedAction } from "./state.js"
-import { connectWebSocket } from "./ws.js"
-import type { AppState } from "./types.js"
-import type { Selection } from "@opentui/core"
-
-type AppProps = {
-  host: string
-  wsPort: number
-  connectBackend: boolean
-}
-
-type MenuFocusTarget = "content" | "ws-input" | "reconnect"
-
-export function App({ host, wsPort, connectBackend }: AppProps) {
-  const renderer = useRenderer()
-  const { width, height } = useTerminalDimensions()
-  const [state, setState] = useState(createInitialState)
-  const [validationError, setValidationError] = useState<string | null>(null)
-  const [wsUrl, setWsUrl] = useState(`ws://${host}:${wsPort}`)
-  const [reconnectVersion, setReconnectVersion] = useState(0)
-  const [menuFocusTarget, setMenuFocusTarget] = useState<MenuFocusTarget>("content")
-  const [toastMessage, setToastMessage] = useState<string | null>(null)
-
-  const connection = useMemo(() => {
-    return connectWebSocket({
-      url: wsUrl,
-      enabled: connectBackend,
-      onLog: (message: string) => setState((current: AppState) => appendLog(current, message)),
-      onStatusChange: (status) => setState((current: AppState) => setConnectionStatus(current, status))
-    })
-  }, [connectBackend, reconnectVersion, wsUrl])
-
-  useEffect(() => {
-    if (!connectBackend) {
-      setState((current: AppState) => appendLog(setConnectionStatus(current, "idle"), "[local] backend integration disabled"))
-    }
-    return () => connection.dispose()
-  }, [connectBackend, connection])
-
-  useEffect(() => {
-    const handleSelection = (selection: Selection) => {
-      const text = selection.getSelectedText()
-      if (!text) {
-        return
-      }
-      renderer.copyToClipboardOSC52(text)
-      setToastMessage(`Copied ${text.length} chars to clipboard`)
-    }
-
-    renderer.on("selection", handleSelection)
-    return () => {
-      renderer.off("selection", handleSelection)
-    }
-  }, [renderer])
-
-  useEffect(() => {
-    if (!toastMessage) {
-      return
-    }
-    const timer = setTimeout(() => {
-      setToastMessage(null)
-    }, 3000)
-    return () => clearTimeout(timer)
-  }, [toastMessage])
-
-  const reconnect = () => {
-    setValidationError(null)
-    setState((current: AppState) => appendLog(current, `[system] reconnect requested: ${wsUrl}`))
-    setReconnectVersion((value) => value + 1)
-  }
-
-  const cycleMenuFocus = (backward: boolean) => {
-    const order: MenuFocusTarget[] = ["ws-input", "reconnect", "content"]
-    const currentIndex = order.indexOf(menuFocusTarget)
-    const nextIndex = backward
-      ? (currentIndex - 1 + order.length) % order.length
-      : (currentIndex + 1) % order.length
-    setMenuFocusTarget(order[nextIndex])
-  }
-
-  useKeyboard((key) => {
-    if (key.ctrl && key.name === "c") {
-      renderer.destroy()
-      return
-    }
-
-    if (state.screen === "menu") {
-      if (menuFocusTarget === "ws-input") {
-        if (key.name === "tab") {
-          cycleMenuFocus(Boolean(key.shift))
-          return
-        }
-        if (key.name === "escape") {
-          setMenuFocusTarget("content")
-        }
-        return
-      }
-
-      if (menuFocusTarget === "reconnect") {
-        if (key.name === "tab") {
-          cycleMenuFocus(Boolean(key.shift))
-          return
-        }
-        if (key.name === "enter" || key.name === "return") {
-          reconnect()
-          return
-        }
-        if (key.name === "escape") {
-          setMenuFocusTarget("content")
-        }
-        return
-      }
-
-      if (key.name === "up") {
-        setState((current: AppState) => updateSelectedAction(current, (current.selectedActionIndex - 1 + menu.length) % menu.length))
-        return
-      }
-      if (key.name === "down") {
-        setState((current: AppState) => updateSelectedAction(current, (current.selectedActionIndex + 1) % menu.length))
-        return
-      }
-      if (key.name === "tab") {
-        cycleMenuFocus(Boolean(key.shift))
-        return
-      }
-      if (key.name === "enter" || key.name === "return") {
-        setValidationError(null)
-        setState((current: AppState) => openAction(current))
-        return
-      }
-      return
-    }
-
-    const inputCount = menu[state.selectedActionIndex].params.length
-
-    if (key.name === "escape") {
-      setValidationError(null)
-      setState((current: AppState) => backToMenu(current))
-      return
-    }
-    if (key.name === "tab") {
-      setState((current: AppState) => nextFocus(current, inputCount))
-      return
-    }
-    if (key.shift && key.name === "tab") {
-      setState((current: AppState) => previousFocus(current, inputCount))
-      return
-    }
-    if ((key.name === "enter" || key.name === "return") && state.focusIndex === inputCount) {
-      if (!validateAction(state.selectedActionIndex, state.formValues)) {
-        setValidationError("Param Invalid")
-        setState((current: AppState) => appendLog(current, "Param Invalid"))
-        return
-      }
-      setValidationError(null)
-      const payload = buildPayload(state.selectedActionIndex, state.formValues)
-      setState((current: AppState) => appendLog(current, `[request] ${payload}`))
-      connection.send(payload)
-    }
-  })
-
-  if (width < 100 || height < 30) {
-    return <text>Window need to larger than 100x30, current={width}x{height}</text>
-  }
-
-  return (
-    <box width="100%" height="100%" flexDirection="column" padding={1} gap={1} position="relative">
-      <box border borderColor="#7c3aed" paddingX={1} paddingY={0} flexDirection="row" alignItems="center" gap={1}>
-        <text>JBS Client OpenTUI</text>
-      </box>
-      {toastMessage ? (
-        <box position="absolute" top={1} right={2} zIndex={20} border borderColor="#3b82f6" backgroundColor="#172554" paddingX={1} paddingY={0}>
-          <text fg="#bfdbfe">{toastMessage}</text>
-        </box>
-      ) : null}
-      <box border borderColor="#2563eb" height={3} minHeight={3} maxHeight={3} paddingX={1} paddingY={0} flexDirection="row" alignItems="center" justifyContent="flex-start" gap={1}>
-        <text fg="#93c5fd">WS</text>
-        <box flexGrow={1}>
-          <input value={wsUrl} onChange={setWsUrl} width="100%" focused={state.screen === "menu" && menuFocusTarget === "ws-input"} />
-        </box>
-        <box
-          border
-          borderColor={state.screen === "menu" && menuFocusTarget === "reconnect" ? "#3b82f6" : "#22c55e"}
-          paddingX={1}
-          paddingY={0}
-          flexGrow={0}
-          flexShrink={0}
-          alignSelf="center"
-          width={13}
-          focusable
-          onMouseDown={() => {
-            setMenuFocusTarget("reconnect")
-            reconnect()
-          }}
-        >
-          <text fg={state.screen === "menu" && menuFocusTarget === "reconnect" ? "#93c5fd" : "#22c55e"}>Reconnect</text>
-        </box>
-        <box flexGrow={0} flexShrink={0} width={12}>
-          <text fg={state.connectionStatus === "connected" ? "#22c55e" : state.connectionStatus === "error" ? "#f87171" : "#facc15"}>
-            {state.connectionStatus}
-          </text>
-        </box>
-      </box>
-      <box flexDirection="row" flexGrow={1} gap={1}>
-        <box width="50%" flexGrow={1}>
-          {state.screen === "menu" ? (
-            <ActionMenu
-              focused={menuFocusTarget === "content"}
-              selectedIndex={state.selectedActionIndex}
-              onChange={(index: number) => setState((current: AppState) => updateSelectedAction(current, index))}
-              onSelect={(index: number) => {
-                setValidationError(null)
-                setState((current: AppState) => openAction(current, index))
-              }}
-            />
-          ) : (
-            <ParamForm
-              actionIndex={state.selectedActionIndex}
-              values={state.formValues}
-              focusIndex={state.focusIndex}
-              focused
-              validationError={validationError}
-              onChange={(index: number, value: string) => setState((current: AppState) => updateFormValue(current, index, value))}
-            />
-          )}
-        </box>
-        <box width="50%" flexGrow={1}>
-          <LogPanel logs={state.logs} focused={false} />
-        </box>
-      </box>
-    </box>
-  )
-}

package/src/components/action-menu.tsx

@@ -1,28 +0,0 @@
-import { menu } from "../protocol.js"
-
-type ActionMenuProps = {
-  focused: boolean
-  selectedIndex: number
-  onChange: (index: number) => void
-  onSelect: (index: number) => void
-}
-
-export function ActionMenu({ focused, selectedIndex, onChange, onSelect }: ActionMenuProps) {
-  return (
-    <box border borderStyle="rounded" borderColor="#d946ef" padding={1} flexGrow={1} title="Input the action?">
-      <select
-        focused={focused}
-        height={19}
-        selectedIndex={selectedIndex}
-        options={menu.map((item) => ({
-          name: item.name,
-          value: item.name,
-          description: `${item.params.length} param${item.params.length === 1 ? "" : "s"}`
-        }))}
-        onChange={(index) => onChange(index)}
-        onSelect={(index) => onSelect(index)}
-      />
-      <text fg="#9ca3af">Enter opens the form. Up and Down move the selection.</text>
-    </box>
-  )
-}

package/src/components/log-panel.tsx

@@ -1,31 +0,0 @@
-import { useEffect, useRef } from "react"
-import type { ScrollBoxRenderable } from "@opentui/core"
-
-type LogPanelProps = {
-  logs: string[]
-  focused?: boolean
-}
-
-export function LogPanel({ logs, focused = false }: LogPanelProps) {
-  const scrollRef = useRef<ScrollBoxRenderable | null>(null)
-
-  useEffect(() => {
-    if (!scrollRef.current) {
-      return
-    }
-    scrollRef.current.scrollTo({ x: 0, y: scrollRef.current.scrollHeight })
-  }, [logs])
-
-  return (
-    <box border borderStyle="rounded" borderColor="#26f7ce" padding={1} flexDirection="column" flexGrow={1} title="Logs">
-      <scrollbox ref={scrollRef} flexGrow={1} focused={focused} stickyScroll stickyStart="bottom">
-        <box flexDirection="column">
-          {logs.length === 0 ? <text fg="#6b7280" selectable>Waiting for logs...</text> : null}
-          {logs.map((log, index) => (
-            <text key={`${index}-${log}`} selectable>{log}</text>
-          ))}
-        </box>
-      </scrollbox>
-    </box>
-  )
-}

package/src/components/param-form.tsx

@@ -1,73 +0,0 @@
-import { useRef } from "react"
-import { menu } from "../protocol.js"
-
-type ParamFormProps = {
-  actionIndex: number
-  values: string[]
-  focusIndex: number
-  focused: boolean
-  validationError: string | null
-  onChange: (index: number, value: string) => void
-}
-
-export function ParamForm({ actionIndex, values, focusIndex, focused, validationError, onChange }: ParamFormProps) {
-  const action = menu[actionIndex]
-  const submitFocused = focused && focusIndex === action.params.length
-  const textareaRefs = useRef<Record<number, { plainText?: string; initialValue?: string } | null>>({})
-
-  return (
-    <box border borderStyle="rounded" borderColor="#d946ef" padding={1} flexDirection="column" gap={1} flexGrow={1} title={action.name}>
-      {action.params.length === 0 ? <text fg="#d1d5db">This action does not need parameters.</text> : null}
-      {action.params.map((param, index) => (
-        <box key={`${action.name}-${param.name}`} flexDirection="column" gap={1}>
-          <text fg="#a7f3d0">{param.name}</text>
-          {param.inputType === "textarea" ? (
-            <line-number minWidth={4} paddingRight={1} fg="#f472b6">
-              <textarea
-                ref={(instance) => {
-                  textareaRefs.current[index] = instance
-                }}
-                initialValue={values[index] ?? ""}
-                height={12}
-                width="100%"
-                focused={focused && focusIndex === index}
-                wrapMode="word"
-                onContentChange={() => onChange(index, textareaRefs.current[index]?.plainText ?? values[index] ?? "")}
-              />
-            </line-number>
-          ) : param.inputType === "select" ? (
-            <select
-              options={(param.options ?? []).map((option) => ({
-                name: option.name,
-                description: option.description,
-                value: option.value
-              }))}
-              selectedIndex={Math.max(0, (param.options ?? []).findIndex((option) => option.value === (values[index] ?? param.value)))}
-              focused={focused && focusIndex === index}
-              height={4}
-              onChange={(selectedIndex, option) => onChange(index, String(option?.value ?? (param.options ?? [])[selectedIndex]?.value ?? param.value))}
-            />
-          ) : (
-            <input
-              value={values[index] ?? ""}
-              onChange={(value) => onChange(index, value)}
-              width="100%"
-              focused={focused && focusIndex === index}
-            />
-          )}
-        </box>
-      ))}
-      <box
-        border
-        borderStyle={submitFocused ? "double" : "single"}
-        borderColor={submitFocused ? "#22c55e" : "#6b7280"}
-        paddingX={2}
-        paddingY={1}
-      >
-        <text fg={submitFocused ? "#22c55e" : "#9ca3af"}>[ Submit ]</text>
-      </box>
-      {validationError ? <text fg="#f87171">{validationError}</text> : null}
-      <text fg="#9ca3af">Tab or Shift+Tab changes form focus. Esc returns to the action menu.</text>
-    </box>
-  )
-}

package/src/components.test.tsx

@@ -1,36 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { testRender } from "@opentui/react/test-utils"
-import { ActionMenu } from "./components/action-menu.js"
-import { LogPanel } from "./components/log-panel.js"
-
-let setup: Awaited<ReturnType<typeof testRender>> | undefined
-
-afterEach(() => {
-  setup?.renderer.destroy()
-  setup = undefined
-})
-
-describe("components", () => {
-  test("ActionMenu renders menu title and options", async () => {
-    setup = await testRender(<ActionMenu focused selectedIndex={0} onChange={() => {}} onSelect={() => {}} />, {
-      width: 70,
-      height: 20
-    })
-    await setup.renderOnce()
-    const frame = setup.captureCharFrame()
-    expect(frame).toContain("Input the action?")
-    expect(frame).toContain("Watch")
-    expect(frame).toContain("Eval")
-  })
-
-  test("LogPanel renders logs and status", async () => {
-    setup = await testRender(<LogPanel logs={["hello", "world"]} />, {
-      width: 60,
-      height: 16
-    })
-    await setup.renderOnce()
-    const frame = setup.captureCharFrame()
-    expect(frame).toContain("Logs")
-    expect(frame).toContain("world")
-  })
-})

package/src/index.tsx

@@ -1,19 +0,0 @@
-import { createCliRenderer } from "@opentui/core"
-import { createRoot } from "@opentui/react"
-import { App } from "./app.js"
-
-function readArg(name: string, fallback: string): string {
-  const args = Bun.argv.slice(2)
-  const index = args.indexOf(name)
-  return index >= 0 && index + 1 < args.length ? args[index + 1] : fallback
-}
-
-const host = readArg("--host", "localhost")
-const wsPort = Number.parseInt(readArg("--ws_port", "18000"), 10)
-const connectBackend = readArg("--connect", "true") !== "false"
-
-const renderer = await createCliRenderer({
-  exitOnCtrlC: false
-})
-
-createRoot(renderer).render(<App host={host} wsPort={wsPort} connectBackend={connectBackend} />)

package/src/protocol.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { buildInitialFormValues, buildPayload, menu, validateAction } from "./protocol.js"
-
-describe("protocol", () => {
-  test("buildInitialFormValues copies defaults", () => {
-    expect(buildInitialFormValues(0)).toEqual(["", "0"])
-    expect(buildInitialFormValues(7)[0]).toContain("ApplicationContext")
-    expect(buildInitialFormValues(3)[2]).toBe("asm")
-  })
-
-  test("validateAction enforces signature checks", () => {
-    expect(validateAction(0, ["com.demo.Service#run", "1"])).toBe(true)
-    expect(validateAction(0, ["com.demo.Service.run", "1"])).toBe(false)
-  })
-
-  test("buildPayload serializes change body request", () => {
-    const payload = JSON.parse(buildPayload(3, ["a.B#c", "java.lang.String, int", "javassist", "return 1;"])) as Record<string, unknown>
-    expect(payload.type).toBe("CHANGE_BODY")
-    expect(payload.className).toBe("a.B")
-    expect(payload.method).toBe("c")
-    expect(payload.paramTypes).toEqual(["java.lang.String", "int"])
-    expect(payload.body).toBe("return 1;")
-    expect(payload.mode).toBe(0)
-    expect(typeof payload.id).toBe("string")
-  })
-
-  test("buildPayload serializes eval and decompile requests", () => {
-    const decompilePayload = JSON.parse(buildPayload(5, ["demo.Service"])) as Record<string, unknown>
-    expect(decompilePayload.type).toBe("DECOMPILE")
-    expect(decompilePayload.className).toBe("demo.Service")
-
-    const evalPayload = JSON.parse(buildPayload(6, ["1 + 1"])) as Record<string, unknown>
-    expect(evalPayload.type).toBe("EVAL")
-    expect(evalPayload.body).toBe("1 + 1")
-  })
-
-  test("menu preserves expected action count", () => {
-    expect(menu.map((item) => item.name)).toEqual(["Watch", "OuterWatch", "Trace", "ChangeBody", "ChangeResult", "Decompile", "Eval", "Exec", "Reset"])
-  })
-})

package/src/protocol.ts

@@ -1,201 +0,0 @@
-import type { FunctionDefinition } from "./types.js"
-
-const engineOptions = [
-  { name: "ASM", description: "Default bytecode engine", value: "asm" },
-  { name: "Javassist", description: "Source-level transformer", value: "javassist" }
-]
-
-function classAndMethodChecker(value: string): boolean {
-  return value.split("#").length === 2
-}
-
-function nonEmptyChecker(value: string): boolean {
-  return value.trim().length > 0
-}
-
-function engineToMode(value: string): number {
-  return value === "javassist" ? 0 : 1
-}
-
-function randomString(length: number): string {
-  const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-  let result = ""
-  for (let index = 0; index < length; index += 1) {
-    result += alphabet[Math.floor(Math.random() * alphabet.length)]
-  }
-  return result
-}
-
-function commonMap(): Record<string, unknown> {
-  return {
-    id: randomString(4),
-    timestamp: Date.now()
-  }
-}
-
-function parseParamTypes(value: string): string[] {
-  return value
-    .split(",")
-    .map((part) => part.trim())
-    .filter((part) => part.length > 0)
-}
-
-function splitSignature(value: string): [string, string] {
-  const [className = "", method = ""] = value.split("#")
-  return [className, method]
-}
-
-export const menu: FunctionDefinition[] = [
-  {
-    name: "Watch",
-    params: [
-      { name: "ClassName#MethodName", inputType: "text", checker: classAndMethodChecker, value: "" },
-      { name: "MinCost", inputType: "text", checker: () => true, value: "0" }
-    ],
-    toPayload: (params: string[]) => JSON.stringify({ ...commonMap(), type: "WATCH", signature: params[0], minCost: Number.parseInt(params[1] || "0", 10) || 0 })
-  },
-  {
-    name: "OuterWatch",
-    params: [
-      { name: "ClassName#MethodName", inputType: "text", checker: classAndMethodChecker, value: "" },
-      { name: "InnerClassName#InnerMethodName", inputType: "text", checker: classAndMethodChecker, value: "" }
-    ],
-    toPayload: (params: string[]) => JSON.stringify({ ...commonMap(), type: "OUTER_WATCH", signature: params[0], innerSignature: params[1] })
-  },
-  {
-    name: "Trace",
-    params: [
-      { name: "ClassName#MethodName", inputType: "text", checker: classAndMethodChecker, value: "" },
-      { name: "MinCost", inputType: "text", checker: () => true, value: "0" },
-      { name: "IgnoreSubMethodZeroCost", inputType: "text", checker: () => true, value: "true" }
-    ],
-    toPayload: (params: string[]) => JSON.stringify({
-      ...commonMap(),
-      type: "TRACE",
-      signature: params[0],
-      minCost: Number.parseInt(params[1] || "0", 10) || 0,
-      ignoreZero: params[2] === "true"
-    })
-  },
-  {
-    name: "ChangeBody",
-    params: [
-      { name: "ClassName#MethodName", inputType: "text", checker: classAndMethodChecker, value: "" },
-      { name: "ParamTypes", inputType: "text", checker: () => true, value: "" },
-      { name: "Engine", inputType: "select", checker: () => true, value: "asm", options: engineOptions },
-      { name: "Body", inputType: "textarea", checker: () => true, value: "" }
-    ],
-    toPayload: (params: string[]) => {
-      const [className, method] = splitSignature(params[0])
-      return JSON.stringify({
-        ...commonMap(),
-        type: "CHANGE_BODY",
-        className,
-        method,
-        paramTypes: parseParamTypes(params[1]),
-        body: params[3],
-        mode: engineToMode(params[2])
-      })
-    }
-  },
-  {
-    name: "ChangeResult",
-    params: [
-      { name: "ClassName#MethodName", inputType: "text", checker: classAndMethodChecker, value: "" },
-      { name: "ParamTypes", inputType: "text", checker: () => true, value: "" },
-      { name: "InnerClassName#InnerMethodName", inputType: "text", checker: classAndMethodChecker, value: "" },
-      { name: "Engine", inputType: "select", checker: () => true, value: "asm", options: engineOptions },
-      { name: "Body", inputType: "textarea", checker: () => true, value: "" }
-    ],
-    toPayload: (params: string[]) => {
-      const [className, method] = splitSignature(params[0])
-      const [innerClassName, innerMethod] = splitSignature(params[2])
-      return JSON.stringify({
-        ...commonMap(),
-        type: "CHANGE_RESULT",
-        className,
-        method,
-        paramTypes: parseParamTypes(params[1]),
-        innerClassName,
-        innerMethod,
-        body: params[4],
-        mode: engineToMode(params[3])
-      })
-    }
-  },
-  {
-    name: "Decompile",
-    params: [
-      { name: "ClassName", inputType: "text", checker: nonEmptyChecker, value: "" }
-    ],
-    toPayload: (params: string[]) => JSON.stringify({
-      ...commonMap(),
-      type: "DECOMPILE",
-      className: params[0]
-    })
-  },
-  {
-    name: "Eval",
-    params: [
-      {
-        name: "Body",
-        inputType: "textarea",
-        checker: nonEmptyChecker,
-        value: "ctx.getBeanDefinitionNames().length"
-      }
-    ],
-    toPayload: (params: string[]) => JSON.stringify({
-      ...commonMap(),
-      type: "EVAL",
-      body: params[0]
-    })
-  },
-  {
-    name: "Exec",
-    params: [
-      {
-        name: "Body",
-        inputType: "textarea",
-        checker: () => true,
-        value: `
-    try {
-      ApplicationContext ctx =
-        (ApplicationContext) SpringUtils.getSpringBootApplicationContext();
-      Global.info(Arrays.toString(ctx.getBeanDefinitionNames()));
-    } catch (Exception e) {
-      Global.error(e.toString(), e);
-    }
-`
-      }
-    ],
-    toPayload: (params: string[]) => JSON.stringify({
-      ...commonMap(),
-      type: "EXEC",
-      body: `package w;
-import w.Global;
-import w.util.SpringUtils;
-import org.springframework.context.ApplicationContext;
-import java.util.*;
-public class Exec{
-  public void exec() {${params[0] ?? ""}}
-}`
-    })
-  },
-  {
-    name: "Reset",
-    params: [],
-    toPayload: () => JSON.stringify({ ...commonMap(), type: "RESET" })
-  }
-]
-
-export function buildInitialFormValues(actionIndex: number): string[] {
-  return menu[actionIndex].params.map((param: FunctionDefinition["params"][number]) => param.value)
-}
-
-export function validateAction(actionIndex: number, values: string[]): boolean {
-  return menu[actionIndex].params.every((param: FunctionDefinition["params"][number], index: number) => param.checker(values[index] ?? ""))
-}
-
-export function buildPayload(actionIndex: number, values: string[]): string {
-  return menu[actionIndex].toPayload(values)
-}