jbs-client 0.0.1 → 0.0.5

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)
-}

package/src/state.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { appendLog, backToMenu, createInitialState, nextFocus, openAction, previousFocus, updateFormValue, updateSelectedAction } from "./state.js"
-
-describe("state helpers", () => {
-  test("openAction builds form state", () => {
-    const initial = updateSelectedAction(createInitialState(), 3)
-    const opened = openAction(initial)
-    expect(opened.screen).toBe("form")
-    expect(opened.focusIndex).toBe(0)
-    expect(opened.formValues.length).toBe(4)
-  })
-
-  test("focus wraps across inputs and submit button", () => {
-    const opened = openAction(updateSelectedAction(createInitialState(), 0))
-    expect(nextFocus(opened, 2).focusIndex).toBe(1)
-    expect(nextFocus({ ...opened, focusIndex: 2 }, 2).focusIndex).toBe(0)
-    expect(previousFocus(opened, 2).focusIndex).toBe(2)
-  })
-
-  test("updateFormValue and backToMenu keep expected data", () => {
-    const opened = openAction(updateSelectedAction(createInitialState(), 5))
-    const updated = updateFormValue(opened, 0, "hello")
-    expect(updated.formValues[0]).toBe("hello")
-    expect(backToMenu(updated).screen).toBe("menu")
-  })
-
-  test("appendLog keeps newest messages first", () => {
-    const state = appendLog(appendLog(createInitialState(), "first"), "second")
-    expect(state.logs).toEqual(["first", "second"])
-  })
-})

package/src/state.ts

@@ -1,77 +0,0 @@
-import { buildInitialFormValues } from "./protocol.js"
-import type { AppState, ConnectionStatus } from "./types.js"
-
-const logMaxLength = 200
-
-export function createInitialState(): AppState {
-  return {
-    screen: "menu",
-    selectedActionIndex: 0,
-    focusIndex: 0,
-    formValues: [],
-    logs: [],
-    connectionStatus: "idle"
-  }
-}
-
-export function openAction(state: AppState, actionIndex = state.selectedActionIndex): AppState {
-  return {
-    ...state,
-    screen: "form",
-    selectedActionIndex: actionIndex,
-    focusIndex: 0,
-    formValues: buildInitialFormValues(actionIndex)
-  }
-}
-
-export function backToMenu(state: AppState): AppState {
-  return {
-    ...state,
-    screen: "menu",
-    focusIndex: 0
-  }
-}
-
-export function updateSelectedAction(state: AppState, actionIndex: number): AppState {
-  return {
-    ...state,
-    selectedActionIndex: actionIndex
-  }
-}
-
-export function updateFormValue(state: AppState, index: number, value: string): AppState {
-  const formValues = [...state.formValues]
-  formValues[index] = value
-  return {
-    ...state,
-    formValues
-  }
-}
-
-export function nextFocus(state: AppState, inputCount: number): AppState {
-  return {
-    ...state,
-    focusIndex: (state.focusIndex + 1) % (inputCount + 1)
-  }
-}
-
-export function previousFocus(state: AppState, inputCount: number): AppState {
-  return {
-    ...state,
-    focusIndex: (state.focusIndex - 1 + inputCount + 1) % (inputCount + 1)
-  }
-}
-
-export function appendLog(state: AppState, message: string): AppState {
-  return {
-    ...state,
-    logs: [...state.logs, message].slice(-logMaxLength)
-  }
-}
-
-export function setConnectionStatus(state: AppState, status: ConnectionStatus): AppState {
-  return {
-    ...state,
-    connectionStatus: status
-  }
-}

package/src/types.ts

@@ -1,34 +0,0 @@
-export type ParamOption = {
-  name: string
-  description: string
-  value: string
-}
-
-export type ParamInputType = "text" | "textarea" | "select"
-
-export type ParamDefinition = {
-  name: string
-  inputType: ParamInputType
-  checker: (value: string) => boolean
-  value: string
-  options?: ParamOption[]
-}
-
-export type FunctionDefinition = {
-  name: string
-  params: ParamDefinition[]
-  toPayload: (params: string[]) => string
-}
-
-export type Screen = "menu" | "form"
-
-export type ConnectionStatus = "idle" | "connecting" | "connected" | "disconnected" | "error"
-
-export type AppState = {
-  screen: Screen
-  selectedActionIndex: number
-  focusIndex: number
-  formValues: string[]
-  logs: string[]
-  connectionStatus: ConnectionStatus
-}

package/src/ws.ts

@@ -1,63 +0,0 @@
-export type ConnectionOptions = {
-  url: string
-  enabled: boolean
-  onLog: (message: string) => void
-  onStatusChange: (status: "connecting" | "connected" | "disconnected" | "error") => void
-}
-
-function formatLog(content: string): string {
-  const timestamp = new Date()
-  const formatted = timestamp.toISOString().replace("T", " ").slice(0, 19)
-  return `[${formatted}] ${content}`
-}
-
-export function connectWebSocket(options: ConnectionOptions): { send: (message: string) => void; dispose: () => void } {
-  let ws: WebSocket | null = null
-  let closed = false
-
-  if (options.enabled) {
-    options.onStatusChange("connecting")
-    try {
-      ws = new WebSocket(options.url)
-      ws.onopen = () => {
-        options.onStatusChange("connected")
-        options.onLog(formatLog(`WebSocket connected: ${options.url}`))
-      }
-      ws.onmessage = (event) => {
-        try {
-          const parsed = JSON.parse(String(event.data)) as { content?: string }
-          options.onLog(formatLog(parsed.content ?? String(event.data)))
-        } catch {
-          options.onLog(formatLog(String(event.data)))
-        }
-      }
-      ws.onerror = () => {
-        options.onStatusChange("error")
-        options.onLog(formatLog(`WebSocket error: ${options.url}`))
-      }
-      ws.onclose = () => {
-        if (!closed) {
-          options.onStatusChange("disconnected")
-          options.onLog(formatLog(`WebSocket disconnected: ${options.url}`))
-        }
-      }
-    } catch (error) {
-      options.onStatusChange("error")
-      options.onLog(formatLog(`WebSocket connect failed (${options.url}): ${String(error)}`))
-    }
-  }
-
-  return {
-    send(message: string) {
-      if (!ws || ws.readyState !== WebSocket.OPEN) {
-        options.onLog(formatLog("WebSocket is not connected"))
-        return
-      }
-      ws.send(message)
-    },
-    dispose() {
-      closed = true
-      ws?.close()
-    }
-  }
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "jsx": "react-jsx",
-    "jsxImportSource": "@opentui/react",
-    "strict": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "types": ["bun-types"]
-  },
-  "include": ["src/**/*", "build.ts"]
-}