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

package/dist/server-standalone.js

@@ -57211,15 +57211,15 @@ class wa {
     return console.error("Error:", { status: e3, message: t2 }), new Response(JSON.stringify({ error: t2 }), { status: e3, headers: { ...this.corsHeaders, "Content-Type": "application/json" } });
   }
 }
-async function ba(e3) {
+function ba(e3) {
   if (e3 instanceof Request) {
-    return (await wa.New({ ...wa.defaultConfig() }))(e3);
+    return wa.New({ ...wa.defaultConfig() })(e3);
   }
   return wa.New(e3);
 }
 
 // src/index.ts
-async function startServer(mcpServer) {
+async function startServer(settings, mcpServer) {
   const widgetPath = findWidgetPath();
   console.log("✅ Widget found:", widgetPath);
   const port = await findAvailablePort(parseInt(process.env.PORT || "3500"));
@@ -57227,11 +57227,12 @@ async function startServer(mcpServer) {
   const app = import_express.default();
   app.use(import_express.default.json());
   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();
   });
+  app.options("*", (req, res) => {
+    res.status(200).end();
+  });
   app.get("/widget.js", (req, res) => {
     try {
       const widgetCode = readFileSync(widgetPath, "utf-8");
@@ -57244,7 +57245,7 @@ async function startServer(mcpServer) {
       res.status(404).send("Widget not found. Please run 'bun run build:widget' first.");
     }
   });
-  app.all("/ask", async (req, res) => {
+  app.post("/ask", async (req, res) => {
     try {
       const body = req.method === "POST" ? JSON.stringify(req.body) : undefined;
       const request = new Request(`http://localhost:${port}${req.url}`, {
@@ -57252,7 +57253,18 @@ async function startServer(mcpServer) {
         headers: new Headers(req.headers),
         body
       });
-      const response = await ba(request);
+      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 = ba({
+        mcpUrl,
+        aiProvider: settings.ai.provider || "",
+        aiModel: settings.ai.model || "",
+        aiToken: settings.ai.token || ""
+      });
+      const response = await askAiHandlerFn(request);
       for (const [key, value] of response.headers.entries()) {
         res.set(key, value);
       }
@@ -57338,5 +57350,129 @@ async function findAvailablePort(startPort = 3500, maxAttempts = 10) {
   throw new Error(`No available ports found between ${startPort} and ${startPort + maxAttempts - 1}`);
 }
 
+// src/utils.ts
+import path from "node:path";
+import fs from "node:fs/promises";
+
+// ../cli-sdk/dist/index.js
+function replaceEnvVars(obj, removeUndefined = false) {
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    if (obj.includes("$")) {
+      return obj.replace(/\$([A-Z_][A-Z0-9_]*)/g, (match, varName) => {
+        const envValue = process.env[varName];
+        if (envValue === undefined) {
+          if (removeUndefined) {
+            return "";
+          }
+          console.warn(`
+⚠️ Environment variable "${varName}" is not set, keeping placeholder: ${match}`);
+          return match;
+        }
+        return envValue;
+      });
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => replaceEnvVars(item, removeUndefined));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = replaceEnvVars(value, removeUndefined);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/utils.ts
+function getSettingsPath() {
+  return path.join(process.cwd(), "askai.json");
+}
+async function loadSetting() {
+  const settingsPath = getSettingsPath();
+  try {
+    await fs.access(settingsPath);
+  } catch (error40) {
+    const settings2 = newSettings();
+    ensureSettings(settings2);
+    return settings2;
+  }
+  const settingsJSON = await fs.readFile(settingsPath, "utf-8");
+  let settings = JSON.parse(settingsJSON);
+  settings = replaceEnvVars(settings, true);
+  ensureSettings(settings);
+  return settings;
+}
+function newSettings() {
+  return {
+    ai: {
+      provider: "",
+      model: "",
+      token: ""
+    },
+    mcp: {
+      url: ""
+    },
+    headers: {}
+  };
+}
+function ensureSettings(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"
+    };
+  }
+}
+
 // server-standalone.ts
-startServer().catch(console.error);
+loadSetting().then(startServer).catch(console.error);