jbs-client 0.0.1

package/src/protocol.ts

@@ -0,0 +1,201 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,15 @@
+{
+  "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"]
+}