chore(server): improve rapfi wrapper from py -> js

GomokuAI/Dockerfile

@@ -8,13 +8,13 @@ RUN apt-get update && apt-get install -y \
     cmake \
     g++ \
     make \
-    python3 \
-    python3-pip \
+    nodejs \
+    npm \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app/GomokuAI
 
-RUN git clone --recurse-submodules https://github.com/dhbloo/rapfi.git rapfi && \
+RUN git clone --recurse-submodules https://github.com/vkuprin/rapfi.git rapfi && \
     cd rapfi/Rapfi && \
     mkdir build && cd build && \
     cmake .. \
@@ -28,10 +28,9 @@ RUN git clone --recurse-submodules https://github.com/dhbloo/rapfi.git rapfi &&
         -DUSE_NEON_DOTPROD=OFF && \
     cmake --build .
 
-RUN pip3 install flask
-
 WORKDIR /app/GomokuAI/rapfi/Rapfi
+COPY wrapper.js .
 
-COPY wrapper.py .
+RUN npm install express
 
-CMD ["python3", "wrapper.py"]
+CMD ["node", "wrapper.js"]

GomokuAI/wrapper.js

@@ -0,0 +1,87 @@
+const express = require("express");
+const { spawn } = require("child_process");
+const { Writable } = require("stream");
+
+const app = express();
+app.use(express.json());
+
+const subprocess = spawn("./build/pbrain-rapfi", ["--mode", "gomocup"], {
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: true,
+});
+
+const commandQueue = [];
+const responseQueue = [];
+
+const inputStream = new Writable({
+    write(chunk, encoding, callback) {
+        subprocess.stdin.write(chunk, encoding, callback);
+    },
+});
+
+subprocess.stdout.on("data", (data) => {
+    const response = data.toString().trim();
+    console.log(`[Subprocess Response]: ${response}`);
+
+    if (responseQueue.length > 0) {
+        const resolve = responseQueue.shift();
+        resolve(response);
+    }
+});
+
+subprocess.on("error", (err) => {
+    console.error(
+        `[Subprocess Error]: Failed to start subprocess - ${err.message}`,
+    );
+});
+
+subprocess.on("exit", (code, signal) => {
+    console.error(
+        `[Subprocess Exit]: Exited with code ${code}, signal ${signal}`,
+    );
+});
+
+app.get("/test", (req, res) => {
+    res.json({ status: "Engine is running" });
+});
+
+app.post("/command", async (req, res) => {
+    const cmd = req.body.command;
+    if (!cmd) {
+        return res.status(400).json({ error: "No command provided" });
+    }
+
+    console.log(`[Command Sent]: ${cmd}`);
+
+    try {
+        inputStream.write(cmd + "\n");
+
+        const response = await new Promise((resolve, reject) => {
+            const timeout = setTimeout(
+                () => reject(new Error("Timeout waiting for response")),
+                5000,
+            );
+            responseQueue.push((data) => {
+                clearTimeout(timeout);
+                resolve(data);
+            });
+        });
+
+        console.log(`[Response Received]: ${response}`);
+        res.json({ response });
+    } catch (err) {
+        console.error(`[Command Error]: ${err.message}`);
+        res.status(408).json({ error: err.message });
+    }
+});
+
+process.on("SIGINT", () => {
+    console.log("Shutting down server and subprocess...");
+    subprocess.kill();
+    process.exit();
+});
+
+const PORT = 5005;
+app.listen(PORT, () => {
+    console.log(`Server running on http://0.0.0.0:${PORT}`);
+});

GomokuClient/packages/gomoku-api/client/hooks/index.ts

@@ -5,7 +5,7 @@ export * from "./useGetApiGameRegisteredActive";
 export * from "./useGetApiGameRegisteredAvailableToJoin";
 export * from "./useGetApiGameRegisteredGameidHistory";
 export * from "./useGetApiProfilesUsernameGames";
-export * from "./useGetApiV1RapfiTest";
+export * from "./useGetApiRapfiTest";
 export * from "./useGetHealth";
 export * from "./usePostApiGameAnonymous";
 export * from "./usePostApiGameAnonymousGameidJoin";

GomokuClient/packages/gomoku-api/client/hooks/useGetApiRapfiTest.ts

@@ -0,0 +1,167 @@
+import client from "../../http";
+import {
+  useQuery,
+  queryOptions,
+  useSuspenseQuery,
+} from "@tanstack/react-query";
+import type {
+  GetApiRapfiTestQueryResponse,
+  GetApiRapfiTestHeaderParams,
+  GetApiRapfiTest500,
+} from "../models/GetApiRapfiTest";
+import type {
+  QueryObserverOptions,
+  UseQueryResult,
+  QueryKey,
+  UseSuspenseQueryOptions,
+  UseSuspenseQueryResult,
+} from "@tanstack/react-query";
+
+type GetApiRapfiTestClient = typeof client<
+  GetApiRapfiTestQueryResponse,
+  GetApiRapfiTest500,
+  never
+>;
+type GetApiRapfiTest = {
+  data: GetApiRapfiTestQueryResponse;
+  error: GetApiRapfiTest500;
+  request: never;
+  pathParams: never;
+  queryParams: never;
+  headerParams: GetApiRapfiTestHeaderParams;
+  response: GetApiRapfiTestQueryResponse;
+  client: {
+    parameters: Partial<Parameters<GetApiRapfiTestClient>[0]>;
+    return: Awaited<ReturnType<GetApiRapfiTestClient>>;
+  };
+};
+export const getApiRapfiTestQueryKey = () =>
+  [{ url: "/api/rapfi/test" }] as const;
+export type GetApiRapfiTestQueryKey = ReturnType<
+  typeof getApiRapfiTestQueryKey
+>;
+export function getApiRapfiTestQueryOptions(
+  headers?: GetApiRapfiTest["headerParams"],
+  options: GetApiRapfiTest["client"]["parameters"] = {},
+) {
+  const queryKey = getApiRapfiTestQueryKey();
+  return queryOptions({
+    queryKey,
+    queryFn: async () => {
+      const res = await client<
+        GetApiRapfiTest["data"],
+        GetApiRapfiTest["error"]
+      >({
+        method: "get",
+        url: `/api/rapfi/test`,
+        headers: { ...headers, ...options.headers },
+        ...options,
+      });
+      return res.data;
+    },
+  });
+}
+/**
+ * @summary Test connection with Rapfi engine
+ * @link /api/rapfi/test
+ */
+export function useGetApiRapfiTest<
+  TData = GetApiRapfiTest["response"],
+  TQueryData = GetApiRapfiTest["response"],
+  TQueryKey extends QueryKey = GetApiRapfiTestQueryKey,
+>(
+  headers?: GetApiRapfiTest["headerParams"],
+  options: {
+    query?: Partial<
+      QueryObserverOptions<
+        GetApiRapfiTest["response"],
+        GetApiRapfiTest["error"],
+        TData,
+        TQueryData,
+        TQueryKey
+      >
+    >;
+    client?: GetApiRapfiTest["client"]["parameters"];
+  } = {},
+): UseQueryResult<TData, GetApiRapfiTest["error"]> & {
+  queryKey: TQueryKey;
+} {
+  const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+  const queryKey = queryOptions?.queryKey ?? getApiRapfiTestQueryKey();
+  const query = useQuery({
+    ...(getApiRapfiTestQueryOptions(
+      headers,
+      clientOptions,
+    ) as unknown as QueryObserverOptions),
+    queryKey,
+    ...(queryOptions as unknown as Omit<QueryObserverOptions, "queryKey">),
+  }) as UseQueryResult<TData, GetApiRapfiTest["error"]> & {
+    queryKey: TQueryKey;
+  };
+  query.queryKey = queryKey as TQueryKey;
+  return query;
+}
+export const getApiRapfiTestSuspenseQueryKey = () =>
+  [{ url: "/api/rapfi/test" }] as const;
+export type GetApiRapfiTestSuspenseQueryKey = ReturnType<
+  typeof getApiRapfiTestSuspenseQueryKey
+>;
+export function getApiRapfiTestSuspenseQueryOptions(
+  headers?: GetApiRapfiTest["headerParams"],
+  options: GetApiRapfiTest["client"]["parameters"] = {},
+) {
+  const queryKey = getApiRapfiTestSuspenseQueryKey();
+  return queryOptions({
+    queryKey,
+    queryFn: async () => {
+      const res = await client<
+        GetApiRapfiTest["data"],
+        GetApiRapfiTest["error"]
+      >({
+        method: "get",
+        url: `/api/rapfi/test`,
+        headers: { ...headers, ...options.headers },
+        ...options,
+      });
+      return res.data;
+    },
+  });
+}
+/**
+ * @summary Test connection with Rapfi engine
+ * @link /api/rapfi/test
+ */
+export function useGetApiRapfiTestSuspense<
+  TData = GetApiRapfiTest["response"],
+  TQueryKey extends QueryKey = GetApiRapfiTestSuspenseQueryKey,
+>(
+  headers?: GetApiRapfiTest["headerParams"],
+  options: {
+    query?: Partial<
+      UseSuspenseQueryOptions<
+        GetApiRapfiTest["response"],
+        GetApiRapfiTest["error"],
+        TData,
+        TQueryKey
+      >
+    >;
+    client?: GetApiRapfiTest["client"]["parameters"];
+  } = {},
+): UseSuspenseQueryResult<TData, GetApiRapfiTest["error"]> & {
+  queryKey: TQueryKey;
+} {
+  const { query: queryOptions, client: clientOptions = {} } = options ?? {};
+  const queryKey = queryOptions?.queryKey ?? getApiRapfiTestSuspenseQueryKey();
+  const query = useSuspenseQuery({
+    ...(getApiRapfiTestSuspenseQueryOptions(
+      headers,
+      clientOptions,
+    ) as unknown as UseSuspenseQueryOptions),
+    queryKey,
+    ...(queryOptions as unknown as Omit<UseSuspenseQueryOptions, "queryKey">),
+  }) as UseSuspenseQueryResult<TData, GetApiRapfiTest["error"]> & {
+    queryKey: TQueryKey;
+  };
+  query.queryKey = queryKey as TQueryKey;
+  return query;
+}