ai: Load playground.

.gitattributes

@@ -33,4 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-*.db filter=lfs diff=lfs merge=lfs -text
+dist/** filter=lfs diff=lfs merge=lfs -text
+build/** filter=lfs diff=lfs merge=lfs -text
+.out/** filter=lfs diff=lfs merge=lfs -text
+.next/** filter=lfs diff=lfs merge=lfs -text
+coverage/** filter=lfs diff=lfs merge=lfs -text
+logs/** filter=lfs diff=lfs merge=lfs -text
+*.log filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,51 +1,22 @@
 #
 # SPDX-FileCopyrightText: Hadad <[email protected]>
-# SPDX-License-Identifier: MIT
+# SPDX-License-Identifier: Apache-2.0
 #
 
-# Use a specific container image for the application
+# Use a specific container image for the sever
 FROM hadadrjt/ai:latest
 
 # Set the main working directory inside the container
-WORKDIR /app/backend
+WORKDIR /node
 
-# Copy the database file into the container
-# This database is a placeholder or dummy,
-# and the core configuration is located in the Environment
-# and Secret Environment settings of Hugging Face Spaces.
-COPY --chown=$UID:$GID src/database/webui.db /app/backend/data/
+# Copy all files into the container
+COPY . .
 
-# Set the database permission
-RUN chmod 777 /app/backend/data/webui.db
+# Install all dependencies
+RUN npm install
 
-# Search Engine Optimization (SEO)
-# Robots Exclusion Protocol
-RUN search='<meta name="robots" content="noindex,nofollow"' && \
-    replace='<meta name="robots" content="index,follow"' && \
-    find /app -type f -name '*.html' -exec grep -l "$search" {} \; | \
-    while IFS= read -r file; do \
-        echo "Processing: $file" && \
-        if sed -i "s|$search|$replace|g" "$file"; then \
-            echo "Success: $file updated"; \
-        else \
-            echo "Error: failed to update $file"; \
-            exit 1; \
-        fi; \
-    done
-# https://umint-ai.hf.space/robots.txt
-COPY --chown=$UID:$GID src/crawlers/robots.txt /app/build/
-# Sitemaps
-# https://umint-ai.hf.space/sitemap.xml
-COPY --chown=$UID:$GID src/crawlers/sitemap.xml /app/build/
-# Google Search Console Tools
-# https://umint-ai.hf.space/google15aba15fe250d693.html
-COPY --chown=$UID:$GID src/webmasters/google.html /app/build/google15aba15fe250d693.html
-# Bing Webmaster Tools
-# https://umint-ai.hf.space/BingSiteAuth.xml
-COPY --chown=$UID:$GID src/webmasters/bing.xml /app/build/BingSiteAuth.xml
+# Open the port so the web can be accessed
+EXPOSE 7860
 
-# Open the port so the application can be accessed
-EXPOSE 8000
-
-# Start the application using the startup script
-CMD ["bash", "start.sh"]
+# Start the server
+CMD ["npm", "start"]

LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2023 pollinations
-Copyright (c) 2025 Hadad <[email protected]>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -1,12 +1,12 @@
 ---
 title: UltimaX Intelligence
 short_description: Premium AI | Tools | Code Interpreter | Web Generator | etc
-license: mit
+license: apache-2.0
 emoji: ⚡
 colorFrom: purple
 colorTo: green
 sdk: docker
-app_port: 8000
+app_port: 7860
 pinned: true
 thumbnail: >-
   https://cdn-uploads.huggingface.co/production/uploads/686e28b405d4ddcdd96adeb2/i9iufR3L-rgj39mk_B9QW.jpeg
@@ -56,6 +56,4 @@ models:
 - Qwen/Qwen3-235B-A22B-Thinking-2507
 - zai-org/GLM-4.5
 - zai-org/GLM-4.5-Air
----
-
-This service is powered by the [Pollinations](https://github.com/pollinations/pollinations) open-source AI community.
+---

index.js

@@ -0,0 +1,208 @@
+//
+// SPDX-FileCopyrightText: Hadad <[email protected]>
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import express from "express";
+import http from "http";
+import { WebSocketServer } from "ws";
+import fetch from "node-fetch";
+import cookieParser from "cookie-parser";
+import path from "path";
+
+const app = express();
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server });
+const OPENAI_API_BASE_URL = process.env.OPENAI_API_BASE_URL || "";
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY || "";
+const UMINT = process.env.UMINT || ``;
+
+app.use(cookieParser());
+
+// Root endpoint.
+app.get("/", (_req, res) => res.send(UMINT));
+
+// Search Engine Optimization (SEO).
+// Robots Exclusion Protocol.
+app.get("/robots.txt", (_req, res) => {
+  res.sendFile(path.resolve("src/crawlers/robots.txt"));
+});  // https://umint-ai.hf.space/robots.txt
+// Sitemaps.
+app.get("/sitemap.xml", (_req, res) => {
+  res.sendFile(path.resolve("src/crawlers/sitemap.xml"));
+});  // https://umint-ai.hf.space/sitemap.xml
+// Google Search Console Tools.
+app.get("/google15aba15fe250d693.html", (_req, res) => {
+  res.sendFile(path.resolve("src/webmasters/google.html"));
+});  // https://umint-ai.hf.space/google15aba15fe250d693.html
+// Bing Webmaster Tools.
+app.get("/BingSiteAuth.xml", (_req, res) => {
+  res.sendFile(path.resolve("src/webmasters/bing.xml"));
+});  // https://umint-ai.hf.space/BingSiteAuth.xml
+// End of SEO.
+
+// Favicon.
+app.get("/assets/images/favicon.ico", (_req, res) => {
+  res.sendFile(path.resolve("assets/images/favicon.ico"));
+});
+
+wss.on("connection", (ws) => {
+  // Abort controller for the currently active streaming request.
+  let currentAbortController = null;
+
+  // Handle incoming messages from the WebSocket client.
+  ws.on("message", async (msg) => {
+    try {
+      const data = JSON.parse(msg.toString());
+
+      // Handle explicit stop request from client.
+      if (data.type === "stop") {
+        if (currentAbortController) {
+          // Abort the active fetch request to stop streaming.
+          currentAbortController.abort();
+          currentAbortController = null;
+        }
+        // Notify client that streaming ended.
+        ws.send(JSON.stringify({ type: "end" }));
+        return;
+      }
+
+      // Extract user message and optional history for context.
+      const message = data.message;
+      const history = data.history || [];
+      // Build messages array with history and the new user message.
+      const setup_messages = [...history, { role: "user", content: message }];
+
+      // Create a new AbortController to allow client to cancel the stream.
+      currentAbortController = new AbortController();
+      const signal = currentAbortController.signal;
+
+      // Send request to the Endpoint.
+      const request = await fetch(OPENAI_API_BASE_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${OPENAI_API_KEY}`,
+        },
+        body: JSON.stringify({
+          model: "gpt-4.1-nano",
+          messages: setup_messages,
+          stream: true,
+          private: true,
+          isPrivate: true
+        }),
+        signal
+      });
+
+      // Handle non 2xx responses by returning an error to the client.
+      if (!request.ok) {
+        const errorData = await request.text();
+        ws.send(JSON.stringify({ type: "error", error: `HTTP ${request.status}: ${request.statusText} - ${errorData}` }));
+        if (currentAbortController) {
+          currentAbortController.abort();
+          currentAbortController = null;
+        }
+        return;
+      }
+
+      // Get the response body stream to read incremental chunks.
+      const reader = request.body;
+      if (!reader) {
+        ws.send(JSON.stringify({ type: "error", error: "Response body is empty" }));
+        if (currentAbortController) {
+          currentAbortController.abort();
+          currentAbortController = null;
+        }
+        return;
+      }
+
+      // Buffer partial data between streamed chunks.
+      let buffer = "";
+      try {
+        // Iterate over stream chunks as they arrive.
+        for await (const chunk of reader) {
+          // If client requested abort, stop processing and inform the client.
+          if (signal.aborted) {
+            ws.send(JSON.stringify({ type: "end" }));
+            if (currentAbortController) {
+              currentAbortController.abort();
+              currentAbortController = null;
+            }
+            return;
+          }
+
+          // Append raw chunk text to the buffer.
+          buffer += chunk.toString();
+
+          // Process full lines separated by newline characters.
+          let idx;
+          while ((idx = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, idx).trim();
+            buffer = buffer.slice(idx + 1);
+
+            if (line.startsWith("data: ")) {
+              const dataStr = line.substring(6).trim();
+              // Skip empty events and the stream terminator.
+              if (!dataStr || dataStr === "[DONE]") continue;
+              try {
+                // Parse JSON payload and extract incremental content.
+                const parsed = JSON.parse(dataStr);
+                const part = parsed?.choices?.[0]?.delta?.content;
+                if (part) {
+                  // Send incremental chunk to the client.
+                  ws.send(JSON.stringify({ type: "chunk", chunk: part }));
+                }
+              } catch (parseError) {
+                // Log parsing errors for debugging.
+                console.error("Error parsing JSON:", parseError, "Data string:", dataStr);
+              }
+            }
+          }
+        }
+      } catch (logs) {
+        // If the fetch was aborted by the client, signal end.
+        if (signal.aborted) {
+          ws.send(JSON.stringify({ type: "end" }));
+        } else {
+          // For unexpected stream errors, log and notify client.
+          console.error("Error:", logs);
+          ws.send(JSON.stringify({ type: "error", error: "Error: " + (logs && logs.message ? logs.message : String(logs)) }));
+        }
+        if (currentAbortController) {
+          currentAbortController.abort();
+          currentAbortController = null;
+        }
+        return;
+      }
+
+      // Normal end of stream, notify client.
+      ws.send(JSON.stringify({ type: "end" }));
+      if (currentAbortController) {
+        currentAbortController.abort();
+        currentAbortController = null;
+      }
+    } catch (e) {
+      // Catch JSON parse errors and other unexpected exceptions.
+      console.error("General error:", e);
+      ws.send(JSON.stringify({ type: "error", error: e.message || "An unknown error occurred" }));
+      if (currentAbortController) {
+        currentAbortController.abort();
+        currentAbortController = null;
+      }
+    }
+  });
+
+  // Ensure any active fetch is aborted when the WebSocket closes.
+  ws.on("close", () => {
+    if (currentAbortController) {
+      currentAbortController.abort();
+      currentAbortController = null;
+    }
+  });
+});
+
+const PORT = process.env.PORT || 7860;
+// Start the HTTP and WebSocket server.
+server.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});

package.json

@@ -0,0 +1,17 @@
+{
+  "name": "UltimaX Intelligence",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "express": "latest",
+    "http": "latest",
+    "ws": "latest",
+    "node-fetch": "latest",
+    "cookie-parser": "latest",
+    "path": "latest"
+  }
+}

src/database/webui.db

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a69bca9badf0df533af496629aee7a691c924a0085d87687d54cb25e2a6c0c48
-size 9211904