@xyd-js/ask-ai-widget 0.0.0-build-87e0566-20251013171826 → 0.0.0-build-6675456-20251014012658

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyd-js/ask-ai-widget",
-  "version": "0.0.0-build-87e0566-20251013171826",
+  "version": "0.0.0-build-6675456-20251014012658",
   "type": "module",
   "main": "dist/server.js",
   "files": [
@@ -17,8 +17,12 @@
     "express": "^4.18.2",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "@xyd-js/ask-ai": "0.0.0-build-87e0566-20251013171826",
-    "@xyd-js/mcp-server": "0.0.0-build-87e0566-20251013171826"
+    "@xyd-js/ask-ai": "0.0.0-build-6675456-20251014012658",
+    "@xyd-js/cli-sdk": "0.1.0-build.0",
+    "@xyd-js/mcp-server": "0.0.0-build-6675456-20251014012658"
+  },
+  "devDependencies": {
+    "openapi-typescript": "^7.9.1"
   },
   "scripts": {
     "build": "bun run build:widget && bun run build:server && bun run build:server-standalone",
@@ -26,6 +30,7 @@
     "build:server": "NODE_ENV=production bun build server.ts --outdir dist --outfile dist/server.js --target node",
     "build:server-standalone": "AS_MCP=false NODE_ENV=production bun build server-standalone.ts --outdir dist --outfile dist --target node",
     "dev": "bun --watch server.ts",
-    "mcp:inspector": "npx @modelcontextprotocol/inspector http://localhost:3500/mcp"
+    "mcp:inspector": "npx @modelcontextprotocol/inspector http://localhost:3500/mcp",
+    "openapi:generate-spec": "npx openapi-typescript ./openapi.yaml -o ./src/__generated__/openapi-spec.ts"
   }
 }

package/server.ts

@@ -1,11 +1,21 @@
 import { MCPServer } from "@xyd-js/mcp-server/mcp";
 
 import { startServer } from "./src/index";
+import { loadSetting } from "./src/utils";
 
-const source = process.env.MCP_SOURCE;
+loadSetting()
+  .then((settings) => {
+    if (!settings.mcp?.url) {
+      throw new Error("MCP_SOURCE is not set");
+    }
 
-if (!source) {
-  throw new Error("MCP_SOURCE is not set");
-}
+    const openApiSource = settings.mcp?.sources?.openapi || "";
+    if (!openApiSource) {
+      console.warn("Open API source is not set");
+    }
 
-startServer(new MCPServer(source)).catch(console.error);
+    const mcpServer = new MCPServer(openApiSource);
+
+    return startServer(settings, mcpServer);
+  })
+  .catch(console.error);

package/src/__generated__/openapi-spec.ts

@@ -0,0 +1,238 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/widget.js": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get widget JavaScript bundle
+         * @description Serves the compiled widget JavaScript bundle
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    petId: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Widget JavaScript bundle */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/javascript": string;
+                    };
+                };
+                /** @description Widget not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/plain": string;
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/ask": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Ask AI a question
+         * @description Send a question to the AI service and get a streaming response
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        /**
+                         * @description The question to ask the AI
+                         * @example What is the weather like today?
+                         */
+                        question: string;
+                        /**
+                         * @description Additional context for the AI
+                         * @example I'm working on a React project
+                         */
+                        context?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Streaming AI response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/plain": string;
+                    };
+                };
+                /** @description Internal server error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "text/plain": string;
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/mcp": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Handle MCP session request
+         * @description Handle Model Context Protocol session requests
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description MCP session established */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description MCP server not available */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        /**
+         * Handle MCP connection request
+         * @description Handle Model Context Protocol connection requests
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description MCP connection established */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description MCP server not available */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        /**
+         * Handle MCP session termination
+         * @description Terminate Model Context Protocol session
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description MCP session terminated */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description MCP server not available */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        Error: {
+            /** @description Error message */
+            message: string;
+            /** @description Error code */
+            code?: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;

package/src/index.ts

@@ -2,13 +2,20 @@ import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { createServer } from "node:http";
 import { fileURLToPath } from "node:url";
+
+import { Router } from 'express';
 import express from "express";
 
 import { handler as askAiHandler } from "@xyd-js/ask-ai/node";
 import type { MCPServer } from "@xyd-js/mcp-server/mcp";
 
+import type { Settings } from "./settings";
+
 // Start the server
-export async function startServer(mcpServer?: MCPServer) {
+export async function startServer(
+  settings: Settings,
+  mcpServer?: MCPServer
+) {
   const widgetPath = findWidgetPath();
   console.log("✅ Widget found:", widgetPath);
 
@@ -23,12 +30,15 @@ export async function startServer(mcpServer?: MCPServer) {
 
   // Set CORS headers
   app.use((req, res, next) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.header("Access-Control-Allow-Headers", "Content-Type");
+    res.header(settings.headers);
     next();
   });
 
+  // Handle preflight OPTIONS requests
+  app.options("*", (req, res) => {
+    res.status(200).end();
+  });
+
   // Serve the widget bundle at /widget.js
   app.get("/widget.js", (req, res) => {
     try {
@@ -46,7 +56,7 @@ export async function startServer(mcpServer?: MCPServer) {
   });
 
   // Handle ask AI requests at /ask
-  app.all("/ask", async (req, res) => {
+  app.post("/ask", async (req, res) => {
     try {
       // Convert Express request to Web API Request
       const body = req.method === "POST" ? JSON.stringify(req.body) : undefined;
@@ -56,7 +66,20 @@ export async function startServer(mcpServer?: MCPServer) {
         body: body,
       });
 
-      const response = (await askAiHandler(request)) as Response;
+      let mcpUrl = settings.mcp?.url || "";
+      if (Array.isArray(mcpUrl)) {
+        console.warn("MCP as array is not supported, using the first one");
+        mcpUrl = mcpUrl[0];
+      }
+
+      const askAiHandlerFn = askAiHandler({
+        mcpUrl: mcpUrl,
+        aiProvider: settings.ai.provider || "",
+        aiModel: settings.ai.model || "",
+        aiToken: settings.ai.token || "",
+      });
+
+      const response = await askAiHandlerFn(request);
 
       // Copy response headers
       for (const [key, value] of response.headers.entries()) {

package/src/settings.ts

@@ -0,0 +1,72 @@
+/**
+ * The settings for the Ask AI widget
+ */
+export interface Settings {
+  /**
+   * The AI settings to use
+   */
+  ai: AI;
+
+  /**
+   * The MCP settings to use
+   */
+  mcp?: MCP;
+
+  /**
+   * The sources to use
+   */
+  sources?: Sources;
+
+  /**
+   * The headers to use
+   * @example { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Requested-With", "Access-Control-Allow-Methods": "GET, POST, OPTIONS, PUT, DELETE", "Access-Control-Max-Age": "86400" }
+   */
+  headers?: Record<string, string>;
+}
+
+export interface AI {
+  /**
+   * The AI provider to use
+   * @example "openai"
+   * @example "anthropic"
+   */
+  provider: string;
+
+  /**
+   * The AI model to use
+   * @example "gpt-4o"
+   * @example "claude-3-5-sonnet-20240620"
+   */
+  model: string;
+
+  /**
+   * The AI token to use
+   * @example "sk-1234567890"
+   */
+  token: string;
+}
+
+export interface MCP {
+  /**
+   * The MCP URL to use
+   * @example "http://localhost:3000/mcp"
+   * @example ["http://localhost:3000/mcp", "http://localhost:3001/mcp"]
+   */
+  url: string | string[];
+}
+
+export interface Sources {
+  /**
+   * The OpenAPI sources to use
+   * @example "http://localhost:3000/openapi.yaml"
+   * @example ["http://localhost:3000/openapi.yaml", "./openapi.yaml"]
+   */
+  openapi: string | string[];
+
+  /**
+   * The LLMs sources to use
+   * @example "http://localhost:3000/llms.tx"
+   * @example ["http://localhost:3000/llms.txt", "./llms.txt"]
+   */
+  llms: string | string[];
+}

package/src/utils.ts

@@ -0,0 +1,107 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+import { Settings } from "./settings";
+
+import { replaceEnvVars } from "@xyd-js/cli-sdk";
+
+function getSettingsPath(): string {
+  return path.join(process.cwd(), "askai.json");
+}
+
+export async function loadSetting(): Promise<Settings> {
+  const settingsPath = getSettingsPath();
+  try {
+    await fs.access(settingsPath);
+  } catch (error) {
+    const settings = newSettings();
+    ensureSettings(settings);
+
+    return settings;
+  }
+
+  const settingsJSON = await fs.readFile(settingsPath, "utf-8");
+  let settings = JSON.parse(settingsJSON);
+  settings = replaceEnvVars(settings, true);
+
+  ensureSettings(settings);
+
+  return settings;
+}
+
+function newSettings(): Settings {
+  return {
+    ai: {
+      provider: "",
+      model: "",
+      token: "",
+    },
+    mcp: {
+      url: "",
+    },
+    headers: {},
+  };
+}
+
+function ensureSettings(settings: Settings) {
+  if (!settings.ai) {
+    settings.ai = {
+      provider: "",
+      model: "",
+      token: "",
+    };
+  }
+
+  if (!settings.mcp) {
+    settings.mcp = {
+      url: "",
+    };
+  }
+
+  if (!settings.sources) {
+    settings.sources = {
+      openapi: "",
+      llms: "",
+    };
+  }
+
+  if (process.env.OPENAPI_SOURCE) {
+    settings.sources.openapi = process.env.OPENAPI_SOURCE;
+    console.log("(env settings): using OPENAPI_SOURCE");
+  }
+
+  if (process.env.LLMS_SOURCE) {
+    settings.sources.llms = process.env.LLMS_SOURCE;
+    console.log("(env settings): using LLMS_SOURCE");
+  }
+
+  if (process.env.MCP_URL) {
+    settings.mcp.url = process.env.MCP_URL;
+    console.log("(env settings): using MCP_URL");
+  }
+
+  if (process.env.AI_PROVIDER) {
+    settings.ai.provider = process.env.AI_PROVIDER;
+    console.log("(env settings): using AI_PROVIDER");
+  }
+
+  if (process.env.AI_MODEL) {
+    settings.ai.model = process.env.AI_MODEL;
+    console.log("(env settings): using AI_MODEL");
+  }
+
+  if (process.env.AI_TOKEN) {
+    settings.ai.token = process.env.AI_TOKEN;
+    console.log("(env settings): using AI_TOKEN");
+  }
+
+  if (!settings.headers || !Object.keys(settings.headers).length) {
+    settings.headers = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Headers":
+        "Content-Type, Authorization, X-Requested-With",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS, PUT, DELETE",
+      "Access-Control-Max-Age": "86400",
+    };
+  }
+}