@redonvn/redai-openapi-generic 0.1.1

package/README.md

@@ -0,0 +1,38 @@
+# @redonvn/redai-openapi-generic
+
+OpenClaw plugin generated from `openapi/redai/generic.json`.
+
+## Build
+
+```bash
+npm run build --workspace @redonvn/redai-openapi-generic
+```
+
+## Install in OpenClaw
+
+```bash
+openclaw plugins install @redonvn/redai-openapi-generic
+openclaw plugins enable redai-openapi-generic
+```
+
+## Runtime config
+
+Add runtime config in `~/.openclaw/openclaw.json`:
+
+```json5
+{
+  "plugins": {
+    "entries": {
+      "redai-openapi-generic": {
+        "enabled": true,
+        "config": {
+          "baseUrl": "https://v2.redai.vn/api",
+          "bearerToken": "YOUR_TOKEN",
+          "workspaceId": "YOUR_WORKSPACE_ID",
+          "baseId": "YOUR_BASE_ID"
+        }
+      }
+    }
+  }
+}
+```

package/dist/index.cjs

@@ -0,0 +1,616 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  catalog: () => tool_catalog_default,
+  default: () => register,
+  spec: () => generic_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+
+// ../redai-agent-sdk/dist/index.js
+var DEFAULT_BASE_URL = "https://api.redai.vn/api/v1";
+var encodeQueryValue = (value) => {
+  if (value === void 0) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item));
+  }
+  return [String(value)];
+};
+var headersToObject = (headers) => {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+var applyPathParams = (pathTemplate, pathParams) => pathTemplate.replace(/\{([^}]+)\}/g, (_, key) => {
+  const raw = pathParams?.[key];
+  if (raw === void 0 || raw === null) {
+    throw new RedaiAgentError(`Missing required path parameter: ${key}`);
+  }
+  return encodeURIComponent(String(raw));
+});
+var buildUrl = (baseUrl, path, query) => {
+  const url = new URL(baseUrl);
+  const normalizedBasePath = url.pathname.replace(/\/+$/, "");
+  const normalizedRequestPath = path.startsWith("/") ? path : `/${path}`;
+  url.pathname = `${normalizedBasePath}${normalizedRequestPath}`.replace(/\/{2,}/g, "/");
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      for (const item of encodeQueryValue(value)) {
+        url.searchParams.append(key, item);
+      }
+    }
+  }
+  return url;
+};
+var parseResponse = async (response) => {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+};
+var RedaiAgentError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "RedaiAgentError";
+    this.status = options?.status;
+    this.body = options?.body;
+  }
+};
+var RedaiAgentClient = class {
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.bearerToken = options.bearerToken;
+    this.apiKey = options.apiKey;
+    this.apiKeyHeader = options.apiKeyHeader ?? "x-api-key";
+    this.defaultHeaders = options.defaultHeaders;
+    this.timeoutMs = options.timeoutMs;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.tenantContext = {
+      workspaceId: options.workspaceId,
+      baseId: options.baseId
+    };
+  }
+  createTenantHeaders(overrides) {
+    const workspaceId = overrides?.workspaceId ?? this.tenantContext.workspaceId;
+    const baseId = overrides?.baseId ?? this.tenantContext.baseId;
+    return {
+      "x-workspace-id": workspaceId,
+      "x-base-id": baseId
+    };
+  }
+  async executeTool(tool, input = {}) {
+    return this.request({
+      method: tool.method,
+      path: tool.path,
+      pathParams: input.path,
+      query: input.query,
+      headers: input.headers,
+      body: input.body
+    });
+  }
+  async request(request) {
+    const url = buildUrl(this.baseUrl, applyPathParams(request.path, request.pathParams), request.query);
+    const controller = new AbortController();
+    const timeout = this.timeoutMs ? setTimeout(() => controller.abort(), this.timeoutMs) : void 0;
+    const headers = this.buildHeaders(request.method, request.headers, request.body !== void 0);
+    try {
+      const response = await this.fetchImpl(url, {
+        method: request.method,
+        headers,
+        body: request.body === void 0 ? void 0 : JSON.stringify(request.body),
+        signal: controller.signal
+      });
+      const data = await parseResponse(response);
+      const result = {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: headersToObject(response.headers),
+        data
+      };
+      if (!response.ok) {
+        throw new RedaiAgentError(`Request failed with status ${response.status}`, {
+          status: response.status,
+          body: data
+        });
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof RedaiAgentError) {
+        throw error;
+      }
+      throw new RedaiAgentError("Request failed", { body: error });
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+  buildHeaders(method, requestHeaders, hasBody) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(this.defaultHeaders ?? {})) {
+      headers.set(key, value);
+    }
+    for (const [key, value] of Object.entries(this.createTenantHeaders())) {
+      if (value !== void 0 && value !== null && value !== "") {
+        headers.set(key, value);
+      }
+    }
+    if (this.bearerToken) {
+      headers.set("authorization", `Bearer ${this.bearerToken}`);
+    } else if (this.apiKey) {
+      headers.set(this.apiKeyHeader ?? "x-api-key", this.apiKey);
+    }
+    for (const [key, value] of Object.entries(requestHeaders ?? {})) {
+      if (value !== void 0 && value !== null && value !== "") {
+        headers.set(key, value);
+      }
+    }
+    if (!headers.has("accept")) {
+      headers.set("accept", "application/json");
+    }
+    if (hasBody && method !== "GET" && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    return headers;
+  }
+};
+
+// tool-catalog.json
+var tool_catalog_default = {
+  pluginId: "redai-openapi-generic",
+  pluginName: "RedAI User API Export - Generic",
+  version: "0.1.0",
+  description: "OpenAPI export cho nh\xF3m API user \u0111\xE3 ch\u1ECDn: Generic.",
+  serverUrl: "https://v2.redai.vn/api",
+  optional: true,
+  tools: [
+    {
+      name: "redai_openapi_generic_genericpageusercontroller_getpublishedgenericpagebypath_v1",
+      description: "L\u1EA5y th\xF4ng tin trang \u0111\xE3 xu\u1EA5t b\u1EA3n theo \u0111\u01B0\u1EDDng d\u1EABn",
+      method: "GET",
+      path: "/v1/user/generic-pages/by-path/{path}",
+      operationId: "genericpageusercontroller_getpublishedgenericpagebypath_v1",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "\u0110\u01B0\u1EDDng d\u1EABn c\u1EE7a trang"
+              }
+            },
+            required: [
+              "path"
+            ],
+            additionalProperties: false
+          }
+        },
+        required: [
+          "path"
+        ],
+        additionalProperties: false,
+        description: "L\u1EA5y th\xF4ng tin trang \u0111\xE3 xu\u1EA5t b\u1EA3n theo \u0111\u01B0\u1EDDng d\u1EABn tool arguments"
+      },
+      tags: [
+        "User Generic Page"
+      ]
+    }
+  ]
+};
+
+// generic.json
+var generic_default = {
+  openapi: "3.0.0",
+  paths: {
+    "/v1/user/generic-pages/by-path/{path}": {
+      get: {
+        operationId: "GenericPageUserController_getPublishedGenericPageByPath_v1",
+        parameters: [
+          {
+            name: "path",
+            required: true,
+            in: "path",
+            description: "\u0110\u01B0\u1EDDng d\u1EABn c\u1EE7a trang",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "Th\xF4ng tin trang",
+            content: {
+              "application/json": {
+                schema: {
+                  allOf: [
+                    {
+                      $ref: "#/components/schemas/ApiResponseDto"
+                    },
+                    {
+                      properties: {
+                        result: {
+                          $ref: "#/components/schemas/UserGenericPageResponseDto"
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        summary: "L\u1EA5y th\xF4ng tin trang \u0111\xE3 xu\u1EA5t b\u1EA3n theo \u0111\u01B0\u1EDDng d\u1EABn",
+        tags: [
+          "User Generic Page"
+        ]
+      }
+    }
+  },
+  info: {
+    title: "RedAI User API Export - Generic",
+    description: "OpenAPI export cho nh\xF3m API user \u0111\xE3 ch\u1ECDn: Generic.",
+    version: "1.0",
+    contact: {
+      name: "RedAI Support",
+      url: "https://redai.com/support",
+      email: "support@redai.com"
+    },
+    license: {
+      name: "MIT",
+      url: "https://opensource.org/licenses/MIT"
+    }
+  },
+  tags: [],
+  servers: [
+    {
+      url: "http://localhost:3000",
+      description: "Local Server"
+    },
+    {
+      url: "http://localhost:3003",
+      description: "Development Server"
+    },
+    {
+      url: "http://14.225.29.196:3003",
+      description: "Test Server"
+    },
+    {
+      url: "https://api-staging.redai.vn",
+      description: "Staging Server"
+    },
+    {
+      url: "https://v2.redai.vn/api",
+      description: "Production Server"
+    }
+  ],
+  components: {
+    schemas: {
+      ApiResponseDto: {
+        type: "object",
+        properties: {
+          code: {
+            type: "number",
+            description: "M\xE3 tr\u1EA1ng th\xE1i (0: Th\xE0nh c\xF4ng, kh\xE1c 0: M\xE3 l\u1ED7i c\u1EE5 th\u1EC3)",
+            example: 0
+          },
+          message: {
+            type: "string",
+            description: "Th\xF4ng \u0111i\u1EC7p m\xF4 t\u1EA3 k\u1EBFt qu\u1EA3",
+            example: "Success"
+          }
+        },
+        required: [
+          "code",
+          "message"
+        ]
+      },
+      UserGenericPageResponseDto: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "ID c\u1EE7a trang",
+            example: "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+          },
+          name: {
+            type: "string",
+            description: "T\xEAn c\u1EE7a trang",
+            example: "Trang li\xEAn h\u1EC7"
+          },
+          description: {
+            type: "string",
+            description: "M\xF4 t\u1EA3 v\u1EC1 trang",
+            example: "Form li\xEAn h\u1EC7 cho kh\xE1ch h\xE0ng",
+            nullable: true
+          },
+          path: {
+            type: "string",
+            description: "\u0110\u01B0\u1EDDng d\u1EABn URL c\u1EE7a trang",
+            example: "lien-he"
+          },
+          config: {
+            type: "object",
+            description: "C\u1EA5u h\xECnh trang d\u1EA1ng JSON",
+            example: {
+              formId: "contact-form",
+              title: "Li\xEAn h\u1EC7 v\u1EDBi ch\xFAng t\xF4i",
+              subtitle: "H\xE3y \u0111\u1EC3 l\u1EA1i th\xF4ng tin, ch\xFAng t\xF4i s\u1EBD li\xEAn h\u1EC7 l\u1EA1i v\u1EDBi b\u1EA1n",
+              groups: []
+            }
+          },
+          publishedAt: {
+            type: "number",
+            description: "Th\u1EDDi \u0111i\u1EC3m xu\u1EA5t b\u1EA3n trang (Unix timestamp)",
+            example: 16733634e5
+          }
+        },
+        required: [
+          "id",
+          "name",
+          "description",
+          "path",
+          "config",
+          "publishedAt"
+        ]
+      }
+    }
+  },
+  externalDocs: {
+    description: "Additional Documentation",
+    url: "https://redai.com/docs"
+  },
+  generatedAt: "2026-03-16T08:19:30.792Z",
+  "x-redai-export-modules": [
+    "generic"
+  ],
+  "x-redai-export-scope": "user"
+};
+
+// index.ts
+var DEFAULT_AUTH_STORE_PATH = "C:\\Users\\Acer\\.openclaw\\workspace-nhan-vien-redai\\auth\\redai-auth.json";
+var typedCatalog = tool_catalog_default;
+var formatToolResult = (payload) => ({
+  content: [
+    {
+      type: "text",
+      text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2)
+    }
+  ]
+});
+var resolvePluginConfig = (api) => api.config?.plugins?.entries?.[typedCatalog.pluginId]?.config ?? {};
+var cloneJson = (value) => JSON.parse(JSON.stringify(value));
+var removeHeadersFromSchema = (schema) => {
+  const cloned = cloneJson(schema ?? { type: "object", properties: {} });
+  const objectSchema = cloned;
+  if (!objectSchema.properties) {
+    objectSchema.properties = {};
+  }
+  delete objectSchema.properties.headers;
+  if (Array.isArray(objectSchema.required)) {
+    objectSchema.required = objectSchema.required.filter((item) => item !== "headers");
+  }
+  objectSchema.additionalProperties = false;
+  return objectSchema;
+};
+var buildAuthWrappedParameters = (tool) => {
+  const baseSchema = removeHeadersFromSchema(tool.parameters);
+  return {
+    ...baseSchema,
+    description: `${tool.description} Uses the logged-in RedAI auth for the current Telegram DM user.`,
+    properties: {
+      telegramUserId: {
+        type: "string",
+        description: "Telegram sender ID from DM metadata. The agent must derive this automatically from the current message."
+      },
+      ...baseSchema.properties ?? {}
+    },
+    required: [
+      "telegramUserId",
+      ...(baseSchema.required ?? []).filter((item) => item !== "telegramUserId")
+    ]
+  };
+};
+var buildAuthToolName = (toolName) => toolName.startsWith("redai_openapi_generic_") ? toolName.replace(/^redai_openapi_generic_/, "redai_openapi_generic_auth_") : "redai_openapi_generic_auth_${toolName}";
+var getAuthStorePath = (runtimeConfig) => runtimeConfig.authStorePath?.trim() || DEFAULT_AUTH_STORE_PATH;
+var ensureStoreDirectory = async (storePath) => {
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(storePath), { recursive: true });
+};
+var loadAuthStore = async (runtimeConfig) => {
+  const storePath = getAuthStorePath(runtimeConfig);
+  try {
+    const raw = await (0, import_promises.readFile)(storePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return { version: 1, users: parsed?.users ?? {} };
+  } catch (error) {
+    const maybeNodeError = error;
+    if (maybeNodeError?.code === "ENOENT") {
+      await ensureStoreDirectory(storePath);
+      await (0, import_promises.writeFile)(storePath, JSON.stringify({ version: 1, users: {} }, null, 2), "utf8");
+      return { version: 1, users: {} };
+    }
+    throw error;
+  }
+};
+var getAuthStoreEntry = async (runtimeConfig, telegramUserId) => {
+  const store = await loadAuthStore(runtimeConfig);
+  return store.users[telegramUserId] ?? null;
+};
+var withRedaiAuth = (runtimeConfig, auth) => {
+  const defaultHeaders = {
+    ...runtimeConfig.defaultHeaders ?? {},
+    "x-workspace-id": auth.workspaceId
+  };
+  if (auth.baseId) {
+    defaultHeaders["x-base-id"] = auth.baseId;
+  } else {
+    delete defaultHeaders["x-base-id"];
+  }
+  return {
+    ...runtimeConfig,
+    bearerToken: auth.bearerToken,
+    apiKey: void 0,
+    apiKeyHeader: void 0,
+    defaultHeaders,
+    workspaceId: auth.workspaceId,
+    baseId: auth.baseId ?? void 0
+  };
+};
+var resolveUserRuntimeConfig = async (api, telegramUserId) => {
+  const runtimeConfig = resolvePluginConfig(api);
+  const authEntry = await getAuthStoreEntry(runtimeConfig, telegramUserId);
+  if (!authEntry || authEntry.status !== "active") {
+    return null;
+  }
+  return {
+    runtimeConfig,
+    scopedConfig: withRedaiAuth(runtimeConfig, authEntry)
+  };
+};
+var authRequiredResult = (telegramUserId) => formatToolResult({
+  ok: false,
+  status: 401,
+  statusText: "AUTH_REQUIRED",
+  data: {
+    message: "Ban chua dang nhap RedAI auth hop le. Hay dung /login <bearerToken> <workspaceId> [baseId] trong DM truoc khi thao tac nghiep vu.",
+    telegramUserId
+  }
+});
+var hasHeadersSection = (tool) => {
+  const parameters = tool.parameters;
+  return Boolean(parameters?.properties?.headers);
+};
+var mergeTenantHeaders = (tool, inputHeaders, runtimeConfig) => {
+  const entries = Object.entries(inputHeaders ?? {}).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => [key, String(value)]);
+  if (hasHeadersSection(tool)) {
+    if (runtimeConfig.workspaceId && !entries.some(([key]) => key.toLowerCase() === "x-workspace-id")) {
+      entries.push(["x-workspace-id", runtimeConfig.workspaceId]);
+    }
+    if (runtimeConfig.baseId && !entries.some(([key]) => key.toLowerCase() === "x-base-id")) {
+      entries.push(["x-base-id", runtimeConfig.baseId]);
+    }
+  }
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+var executeCatalogTool = async (runtimeConfig, tool, rawParams) => {
+  const client = new RedaiAgentClient({
+    ...runtimeConfig,
+    baseUrl: runtimeConfig.baseUrl ?? typedCatalog.serverUrl
+  });
+  const params = rawParams ?? {};
+  return client.executeTool(tool, {
+    path: params.path,
+    query: params.query,
+    body: params.body,
+    headers: mergeTenantHeaders(tool, params.headers, runtimeConfig)
+  });
+};
+var registerAuthProxyTool = (api, tool) => {
+  api.registerTool(
+    {
+      name: buildAuthToolName(tool.name),
+      description: `${tool.description} Uses the logged-in RedAI auth for the current Telegram DM user.`,
+      parameters: buildAuthWrappedParameters(tool),
+      execute: async (_id, rawParams) => {
+        const params = rawParams ?? {};
+        const telegramUserId = String(params.telegramUserId ?? "");
+        const resolved = await resolveUserRuntimeConfig(api, telegramUserId);
+        if (!resolved) {
+          return authRequiredResult(telegramUserId);
+        }
+        const forwardedParams = { ...params };
+        delete forwardedParams.telegramUserId;
+        try {
+          const response = await executeCatalogTool(resolved.scopedConfig, tool, forwardedParams);
+          return formatToolResult(response.data);
+        } catch (error) {
+          if (error instanceof RedaiAgentError) {
+            return formatToolResult({
+              ok: false,
+              status: error.status ?? 500,
+              statusText: error.message,
+              data: error.body
+            });
+          }
+          return formatToolResult({
+            ok: false,
+            status: 500,
+            statusText: "PLUGIN_EXECUTION_FAILED",
+            data: String(error)
+          });
+        }
+      }
+    },
+    { optional: typedCatalog.optional ?? true }
+  );
+};
+function register(api) {
+  for (const tool of typedCatalog.tools) {
+    api.registerTool(
+      {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+        execute: async (_id, rawParams) => {
+          try {
+            const response = await executeCatalogTool(resolvePluginConfig(api), tool, rawParams);
+            return formatToolResult(response.data);
+          } catch (error) {
+            if (error instanceof RedaiAgentError) {
+              return formatToolResult({
+                ok: false,
+                status: error.status ?? 500,
+                statusText: error.message,
+                data: error.body
+              });
+            }
+            return formatToolResult({
+              ok: false,
+              status: 500,
+              statusText: "PLUGIN_EXECUTION_FAILED",
+              data: String(error)
+            });
+          }
+        }
+      },
+      { optional: typedCatalog.optional ?? true }
+    );
+  }
+  for (const tool of typedCatalog.tools) {
+    registerAuthProxyTool(api, tool);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  catalog,
+  spec
+});
+//# sourceMappingURL=index.cjs.map