Update index.js

index.js

@@ -1,121 +1,149 @@
-/**
- * Sunny - OpenAI-like API Server for testing NodeJS code
- */
 const express = require('express');
+const bodyParser = require('body-parser');
+const fetch = require('node-fetch');
+const { exec } = require('child_process');
+
 const app = express();
 const port = 7860;
-const bodyParser = require('body-parser');
-const vm = require('vm');
 
 app.use(bodyParser.json());
 app.use(bodyParser.urlencoded({ extended: true }));
 
-// Root endpoint
 app.get("/", (req, res) => {
   res.set('Content-Type', 'text/plain');
-  res.send(`☀️ Sunny!
-> You're using this server to eval your code with Sunny!
+  res.send(`☀️ Sunny API Server
 
-This server model only supports NodeJS. It doesn't generate text, only executes code for testing.
+> You're using this server to test or eval code with Sunny!
 
-🛂 For educational purposes only. Do not use this server for illegal activities.
+Supported models:
+- sunny: Run Node.js code
+- sunny-shell: Run real shell commands
+- sunny-plus: Get long-form code explanations via text.pollinations.ai
 
-> Usage:
-  - Use OpenWebUI:
-    Administrators Settings > Connections > Add Connection (OpenAI)
-  - Use h3 HF Spaces:
-    https://huggingface.co/spaces/katsukiai/h3
+🛂 Educational use only.
 `);
 });
 
-// /models - Return the models
+// Models endpoint
 app.get("/models", (req, res) => {
-  res.set('Content-Type', 'application/json');
-  res.send({
+  res.json({
     object: "list",
     data: [
       {
         id: "sunny",
         object: "model",
-        created: Math.floor(Date.now() / 1000),
         owned_by: "sunny-dev",
-        permission: [],
-        root: "sunny",
-        parent: null
+        created: Date.now()
+      },
+      {
+        id: "sunny-shell",
+        object: "model",
+        owned_by: "sunny-dev",
+        created: Date.now()
       },
       {
-        id: "sunny-beta",
+        id: "sunny-plus",
         object: "model",
-        created: Math.floor(Date.now() / 1000),
         owned_by: "sunny-dev",
-        permission: [],
-        root: "sunny-beta",
-        parent: null
+        created: Date.now()
       }
     ]
   });
 });
 
-// /chat/completions - Secure sandboxed code execution
+// Chat/completions endpoint
 app.post("/chat/completions", async (req, res) => {
-  const input = req.body?.messages?.[0]?.content || "";
-  let output = '';
-  let logs = [];
-  let promptTokens = input.split(/\s+/).length; // Rough estimate of prompt tokens
-
-  try {
-    const sandbox = {
-      console: {
-        log: (...args) => logs.push(args.join(" "))
-      },
-      result: undefined
-    };
-
-    const context = vm.createContext(sandbox);
-    const wrappedCode = `
-      (async () => {
-        try {
-          result = await (async () => { ${input} })();
-        } catch (e) {
-          result = 'Runtime Error: ' + e.message;
-        }
-      })()
-    `;
-
-    const script = new vm.Script(wrappedCode);
-
-    await script.runInContext(context, { timeout: 1000 });
-
-    output = sandbox.result;
-  } catch (err) {
-    output = 'Execution Timeout or VM Error: ' + err.message;
+  const model = req.body.model || "sunny";
+  const messages = req.body.messages || [];
+
+  const outputs = [];
+  const logs = [];
+  let totalPromptTokens = 0;
+
+  for (const msg of messages) {
+    const inputCode = msg.content || "";
+    const promptTokens = inputCode.split(/\s+/).length;
+    totalPromptTokens += promptTokens;
+
+    try {
+      if (model === "sunny-shell") {
+        // Shell execution
+        const result = await new Promise((resolve) => {
+          exec(inputCode, { timeout: 10000 }, (err, stdout, stderr) => {
+            if (err) return resolve(`Shell Error: ${stderr || err.message}`);
+            resolve(stdout || "No output from shell.");
+          });
+        });
+        outputs.push(result.trim());
+        logs.push("Executed Shell: " + inputCode);
+      }
+
+      else if (model === "sunny-plus") {
+        // Pollinations AI explanation
+        const pollinationURL = `https://text.pollinations.ai/${encodeURIComponent("Explain this code: " + inputCode)}`;
+        const response = await fetch(pollinationURL);
+        const explanation = await response.text();
+        outputs.push(explanation.trim());
+        logs.push("Fetched explanation via Pollinations.");
+      }
+
+      else {
+        // Default NodeJS eval
+        const consoleCapture = [];
+        const customConsole = {
+          log: (...args) => consoleCapture.push(args.join(" ")),
+          error: (...args) => consoleCapture.push("ERROR: " + args.join(" "))
+        };
+
+        const wrappedCode = `
+          (async () => {
+            let result;
+            try {
+              const console = customConsole;
+              result = await (async () => { ${inputCode} })();
+              if (result !== undefined) console.log(result);
+            } catch (e) {
+              console.error("Runtime Error:", e.message);
+            }
+          })();
+        `;
+        eval(wrappedCode);
+        outputs.push(consoleCapture.join("\n") || "Execution Finished.");
+        logs.push("NodeJS evaluated.");
+      }
+    } catch (err) {
+      outputs.push("Execution Error: " + err.message);
+      logs.push("Caught Error: " + err.message);
+    }
   }
 
-  let completionTokens = output.split(/\s+/).length; // Rough estimate of completion tokens
+  const outputText = outputs.join("\n\n");
+  const completionTokens = outputText.split(/\s+/).length;
 
   res.json({
-    id: "chatcmpl-" + Math.random().toString(36).substr(2, 9),
+    id: "chatcmpl-" + Math.random().toString(36).substring(2, 10),
     object: "chat.completion",
     created: Math.floor(Date.now() / 1000),
-    model: req.body.model || "sunny",
+    model,
     choices: [
       {
         index: 0,
         message: {
           role: "assistant",
-          content: output
+          content: outputText
         },
         finish_reason: "stop"
       }
     ],
     usage: {
-      prompt_tokens: promptTokens,
+      prompt_tokens: totalPromptTokens,
       completion_tokens: completionTokens,
-      total_tokens: promptTokens + completionTokens
-    }
+      total_tokens: totalPromptTokens + completionTokens
+    },
+    logs
   });
 });
 
 app.listen(port, () => {
-  console.log(`☀️ Sunny listening on port ${port}!`);
+  console.log(`Sunny server running on port ${port}`);
 });