plugin_server

Sleeping

App Files Files Community

Pepguy commited on Nov 27, 2025

Commit

b06a41a

verified ·

1 Parent(s): 1c8cb1b

Update app.js

Browse files

Files changed (1) hide show

app.js +384 -142

app.js CHANGED Viewed

@@ -1,165 +1,407 @@
-import { serve } from "bun";
-import { Expo } from "expo-server-sdk";
-const expo = new Expo();
-const events = [];
-const html = `
-<!DOCTYPE html><html><head><title>Timed Event Scheduler</title></head><body>
-<h1>Schedule Timed Event</h1>
-<form onsubmit="submitEvent(event)">
-  <label>ID: <input type="text" id="id" required /></label><br />
-  <label>Delay (sec): <input type="number" id="delay" required /></label><br />
-  <label>Message: <input type="text" id="message" /></label><br />
-  <label>Event Type:
-    <select id="type">
-      <option value="timeout">Timeout</option>
-      <option value="interval">Interval</option>
-      <option value="webhook">Webhook</option>
-    </select>
-  </label><br />
-  <label>Repeat Every (sec): <input type="number" id="repeat" /></label><br />
-  <label>Expo Token(s) (comma-separated): <input type="text" id="tokens" /></label><br />
-  <label>Webhook URL: <input type="text" id="webhookUrl" /></label><br />
-  <label>Webhook Payload (JSON): <textarea id="payload"></textarea></label><br />
-  <button type="submit">Submit</button>
-</form>
-<script>
-async function submitEvent(e) {
-  e.preventDefault();
-  const id = document.getElementById('id').value;
-  const delay = parseInt(document.getElementById('delay').value);
-  const message = document.getElementById('message').value;
-  const type = document.getElementById('type').value;
-  const repeat = parseInt(document.getElementById('repeat').value || 0);
-  const tokens = document.getElementById('tokens').value.split(',').map(t => t.trim()).filter(Boolean);
-  const webhookUrl = document.getElementById('webhookUrl').value;
-  const payloadText = document.getElementById('payload').value;
-  let payload = {};
-  try {
-    if (payloadText) payload = JSON.parse(payloadText);
-  } catch {
-    alert('Invalid JSON payload');
-    return;
-  }
-  const res = await fetch('/events', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ id, delay, message, type, repeat, expoTokens: tokens, webhookUrl, payload })
   });
-  alert(await res.text());
 }
-</script>
-</body></html>
 `;
-serve({
-  port: 7860,
-  fetch: async (req) => {
-    const url = new URL(req.url);
-    if (req.method === "GET" && url.pathname === "/") {
-      return new Response(html, { headers: { "Content-Type": "text/html" } });
     }
-    // POST /events - Create Event
-    if (req.method === "POST" && url.pathname === "/events") {
-      try {
-        const body = await req.json();
-        const { id, delay, message, type, repeat, expoTokens, webhookUrl, payload } = body;
-        if (!id || !delay || !type) {
-          return new Response("Missing 'id', 'delay', or 'type'", { status: 400 });
-        }
-        if (events.find(e => e.id === id)) {
-          return new Response("Event ID already exists", { status: 409 });
-        }
-        events.push({
-          id,
-          timestamp: Date.now() + delay * 1000,
-          type,
-          repeat: type === "interval" && repeat ? repeat * 1000 : undefined,
-          data: {
-            message,
-            expoTokens: Array.isArray(expoTokens) ? expoTokens : [],
-            webhookUrl,
-            payload
-          }
-        });
-        return new Response("Event scheduled", { status: 200 });
-      } catch (err) {
-        return new Response("Invalid JSON", { status: 400 });
-      }
     }
-    // DELETE /events/:id - Remove Event
-    if (req.method === "DELETE" && url.pathname.startsWith("/events/")) {
-      const id = url.pathname.split("/")[2];
-      const index = events.findIndex(e => e.id === id);
-      if (index === -1) return new Response("Event not found", { status: 404 });
-      events.splice(index, 1);
-      return new Response("Event deleted", { status: 200 });
-    }
-    return new Response("Not Found", { status: 404 });
   }
 });
-// Event Loop
-setInterval(async () => {
-  const now = Date.now();
-  const due = events.filter(e => e.timestamp <= now);
-  for (const e of due) {
-    console.log(`⏰ Executing event: ${e.id} (${e.type})`);
-    // Expo Notifications
-    if (e.data.expoTokens?.length && e.data.message) {
-      console.log("found a notifications events")
-      const messages = e.data.expoTokens
-        .filter(t => Expo.isExpoPushToken(t))
-        .map(token => ({
-          to: token,
-          sound: 'default',
-          title: '⏰ Scheduled Event',
-          body: e.data.message,
-          data: {}
-        }));
-      for (const chunk of expo.chunkPushNotifications(messages)) {
-        try {
-          await expo.sendPushNotificationsAsync(chunk);
-        } catch (err) {
-          console.error("🔥 Expo error:", err);
-        }
-      }
     }
-    // Webhook Trigger
-    if (e.type === "webhook" && e.data.webhookUrl) {
-      console.log("found a webhook event")
-      try {
-        await fetch(e.data.webhookUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(e.data.payload || {})
         });
-        console.log(`📡 Webhook fired for ${e.id}`);
-      } catch (err) {
-        console.error(`❌ Webhook failed for ${e.id}`, err);
       }
-    }
-    // Repeat or remove
-    if (e.type === "interval" && e.repeat) {
-      e.timestamp = now + e.repeat;
-    } else {
-      const i = events.findIndex(ev => ev.id === e.id);
-      if (i !== -1) events.splice(i, 1);
     }
   }
-}, 1000);

+// server.js
+// ESM Node (package.json should contain "type": "module")
+// Install: npm install express body-parser cors @google/genai
+// Run: GEMINI_API_KEY=your_key node server.js
+import express from "express";
+import bodyParser from "body-parser";
+import cors from "cors";
+import { GoogleGenAI } from "@google/genai";
+const PORT = process.env.PORT ? Number(process.env.PORT) : 7860;
+if (!process.env.GEMINI_API_KEY) {
+  console.error("GEMINI_API_KEY environment variable is required.");
+  process.exit(1);
+}
+const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+const app = express();
+app.use(cors());
+app.use(bodyParser.json({ limit: "2mb" }));
+/**
+ * In-memory store (prototype). For production, replace with persistent storage.
+ */
+const projects = new Map();
+const simpleId = (prefix = "") => prefix + Math.random().toString(36).slice(2, 9);
+/**
+ * Action vocabulary — keep plugin and server in sync.
+ */
+const VALID_ACTIONS = [
+  "create_part",
+  "create_model",
+  "create_meshpart",
+  "create_complex_mesh",
+  "create_union",
+  "create_script",
+  "attach_script",
+  "edit_script",
+  "set_property",
+  "move_to",
+  "rotate_to",
+  "set_parent",
+  "delete",
+  "apply_texture",
+  "weld",
+  "unweld",
+  "create_rig",
+  "apply_animation",
+  "feedback_request",
+  "list_workspace",
+  "finish"
+];
+/**
+ * Validate/prepare model output tasks (ensure allowed actions, add ids)
+ */
+function validateAndPrepareTasks(arr) {
+  if (!Array.isArray(arr)) throw new Error("Model output must be a JSON array of tasks.");
+  return arr.map((t) => {
+    if (!t || typeof t !== "object") throw new Error("Each task must be an object.");
+    if (!t.action) throw new Error("Each task must have an action field.");
+    if (!VALID_ACTIONS.includes(t.action)) throw new Error(`Invalid action from model: ${t.action}`);
+    const id = t.id || simpleId("cmd_");
+    const params = t.params && typeof t.params === "object" ? t.params : {};
+    return { id, action: t.action, params, target_ref: t.target_ref || null };
   });
+}
+/**
+ * generateTasks(project)
+ * Uses Gemini to convert description + project state into an ordered JSON array of tasks.
+ */
+async function generateTasks(project) {
+  // Summarize project state (concise)
+  const historySample = (project.history || []).slice(-20).map(h => ({
+    commandId: h.commandId,
+    status: h.status,
+    message: h.message ? (typeof h.message === "string" ? (h.message.length > 120 ? h.message.slice(0, 117) + "..." : h.message) : null) : null,
+    target_ref: h.target_ref || null,
+    ts: h.ts
+  }));
+  const refsKeys = Object.keys(project._refs || {}).slice(0, 200);
+  const queuedCount = project.commandQueue ? project.commandQueue.length : 0;
+  const tasksCount = project.tasks ? project.tasks.length : 0;
+  const status = project.status || "unknown";
+  const stateSummary = {
+    projectId: project.id,
+    status,
+    queuedCount,
+    tasksCount,
+    recentHistory: historySample,
+    refsSummary: refsKeys
+  };
+  const systemPrompt = `
+You are a precise assistant that converts a high-level Roblox project description into an ordered JSON array of low-level editor tasks. Be spatially aware: reason about coordinates (x,y,z), sizes, rotations (euler degrees as {x,y,z}), orientations, and parent/child relationships. For every object you create, assign a stable "target_ref" string (short alphanumeric) that later tasks can reference.
+Return ONLY valid JSON — a single array, no commentary.
+Allowed actions (use exactly these): ${VALID_ACTIONS.join(", ")}.
+Task object shape:
+{
+  "action": "<action>",
+  "params": { ... },           // numbers, strings, booleans, objects with numeric x,y,z, etc.
+  "target_ref": "<optional-ref>" // for create_* actions include this for reference
 }
+Important rules:
+- Spatial parameters use explicit numeric fields: position: { x, y, z }, size: { x, y, z }, rotation: { x, y, z } (degrees).
+- When referencing an earlier-created object, use params.target_ref exactly as the ref string returned earlier.
+- Do not reference Roblox-specific paths (like Workspace.Model.Part).
+- Use only the allowed actions listed above.
+- If you need the plugin to evaluate the scene and return properties (for feedback), use actions "feedback_request" or "list_workspace".
+- End the sequence with an action "finish" when the project is complete.
+EXISTING PROJECT STATE (read-only; use to decide next tasks):
+${JSON.stringify(stateSummary, null, 2)}
+Now produce tasks for this project:
+${JSON.stringify({ id: project.id, description: project.description })}
 `;
+  const resp = await ai.models.generateContent({
+    model: "gemini-2.5-flash",
+    contents: systemPrompt,
+    temperature: 0.0,
+    maxOutputTokens: 2000
+  });
+  const text = resp?.text ?? (resp?.data?.[0]?.text ?? "");
+  let arr;
+  try {
+    arr = JSON.parse(text);
+  } catch (err) {
+    // Try to extract substring
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    if (start >= 0 && end > start) {
+      arr = JSON.parse(text.slice(start, end + 1));
+    } else {
+      throw new Error("Could not parse JSON from model output: " + text.slice(0, 1000));
     }
+  }
+  return validateAndPrepareTasks(arr);
+}
+/**
+ * Create project endpoint
+ * Body: { description: string, projectId?: string }
+ */
+app.post("/projects", async (req, res) => {
+  try {
+    const description = req.body.description;
+    if (!description || typeof description !== "string") {
+      return res.status(400).json({ error: "description string required in body" });
     }
+    const projectId = req.body.projectId || simpleId("proj_");
+    if (projects.has(projectId)) return res.status(400).json({ error: "projectId already exists" });
+    const project = {
+      id: projectId,
+      description,
+      status: "queued",
+      tasks: [],
+      commandQueue: [],
+      pendingResults: new Map(),
+      running: false,
+      history: [], // { commandId, status, message, extra, target_ref, ts }
+      _refs: {}    // mapping: target_ref -> { commandId, extra, ts }
+    };
+    projects.set(projectId, project);
+    // Start background orchestrator (non-blocking)
+    runProject(project).catch((err) => {
+      project.status = "error";
+      console.error("runProject error:", err);
+    });
+    return res.status(202).json({ projectId, status: "accepted" });
+  } catch (err) {
+    console.error("projects POST error", err);
+    return res.status(500).json({ error: err.message });
   }
 });
+/**
+ * Tweak / prompt endpoint — now includes full project context so the model knows what has been done.
+ * Body: { prompt: string }
+ */
+app.post("/projects/:projectId/prompt", async (req, res) => {
+  const project = projects.get(req.params.projectId);
+  if (!project) return res.status(404).json({ error: "project not found" });
+  const prompt = req.body.prompt;
+  if (!prompt || typeof prompt !== "string") return res.status(400).json({ error: "prompt required" });
+  try {
+    const contextSummary = {
+      id: project.id,
+      status: project.status,
+      queuedCount: project.commandQueue.length,
+      tasksCount: project.tasks.length,
+      recentHistory: (project.history || []).slice(-50).map(h => ({ commandId: h.commandId, status: h.status, target_ref: h.target_ref })),
+      refsKeys: Object.keys(project._refs || {}).slice(0, 200)
+    };
+    const pseudoProject = {
+      id: project.id,
+      description: `${project.description}\n\n---\nContextSummary: ${JSON.stringify(contextSummary)}\n\nUserTweak: ${prompt}`
+    };
+    const newTasks = await generateTasks(pseudoProject);
+    // Append tasks to the project's task list
+    project.tasks.push(...newTasks);
+    return res.json({ appended: newTasks.length, tasks: newTasks });
+  } catch (err) {
+    console.error("prompt endpoint error:", err);
+    return res.status(500).json({ error: err.message });
+  }
+});
+/**
+ * Direct model endpoint for manual calls (returns Gemini text)
+ * Body: { prompt: string }
+ */
+app.post("/model", async (req, res) => {
+  try {
+    const prompt = req.body.prompt;
+    if (!prompt || typeof prompt !== "string") return res.status(400).json({ error: "prompt required" });
+    const resp = await ai.models.generateContent({
+      model: "gemini-2.5-flash",
+      contents: prompt,
+      temperature: 0.0,
+      maxOutputTokens: 1500
+    });
+    return res.json({ text: resp?.text ?? "" });
+  } catch (err) {
+    console.error("/model error", err);
+    return res.status(500).json({ error: err.message });
+  }
+});
+/**
+ * Plugin polling: GET next command or 204 if none
+ */
+app.get("/projects/:projectId/next", (req, res) => {
+  const project = projects.get(req.params.projectId);
+  if (!project) return res.status(404).json({ error: "project not found" });
+  if (project.commandQueue.length > 0) {
+    const cmd = project.commandQueue.shift();
+    return res.json(cmd);
+  }
+  return res.status(204).end();
+});
+/**
+ * Plugin posts execution result. This records history and resolves waiters.
+ * Body: { commandId, status: "ok"|"error", message?: string, extra?: any, target_ref?: string }
+ */
+app.post("/projects/:projectId/result", (req, res) => {
+  const project = projects.get(req.params.projectId);
+  if (!project) return res.status(404).json({ error: "project not found" });
+  const { commandId, status, message, extra, target_ref } = req.body;
+  if (!commandId || !status) return res.status(400).json({ error: "commandId and status required" });
+  // Record in history
+  const entry = {
+    commandId,
+    status,
+    message: message || null,
+    extra: extra || null,
+    target_ref: target_ref || null,
+    ts: Date.now()
+  };
+  project.history = project.history || [];
+  project.history.push(entry);
+  // Map target_ref if present and OK
+  if (target_ref && status === "ok") {
+    project._refs = project._refs || {};
+    project._refs[target_ref] = { commandId, extra, ts: Date.now() };
+  }
+  // Resolve pending waiter if present
+  const waiter = project.pendingResults.get(commandId);
+  if (waiter) {
+    project.pendingResults.delete(commandId);
+    waiter.resolve({ status, message, extra, target_ref });
+    return res.json({ ok: true });
+  }
+  // Otherwise accept and return
+  return res.json({ ok: true, note: "recorded result (no pending waiter)" });
+});
+/**
+ * Status endpoint
+ */
+app.get("/status/:projectId", (req, res) => {
+  const project = projects.get(req.params.projectId);
+  if (!project) return res.status(404).json({ error: "project not found" });
+  return res.json({
+    id: project.id,
+    status: project.status,
+    queuedCommands: project.commandQueue.length,
+    totalTasks: project.tasks.length,
+    refs: project._refs || {},
+    historyLength: (project.history || []).length
+  });
+});
+/**
+ * Simple list of projects (debug)
+ */
+app.get("/projects", (req, res) => {
+  const list = Array.from(projects.values()).map((p) => ({
+    id: p.id,
+    description: p.description,
+    status: p.status,
+    queuedCommands: p.commandQueue.length,
+    tasks: p.tasks.length
+  }));
+  return res.json(list);
+});
+/**
+ * Orchestrator per project
+ * - If no tasks: generate from description
+ * - Iterate tasks, push to commandQueue, wait for plugin result, then continue
+ */
+async function runProject(project) {
+  if (project.running) return;
+  project.running = true;
+  project.status = "running";
+  try {
+    // If no tasks, generate initial plan
+    if (!project.tasks || project.tasks.length === 0) {
+      project.tasks = await generateTasks(project);
     }
+    // Iterate tasks
+    for (const task of project.tasks) {
+      // push to queue
+      project.commandQueue.push(task);
+      // Wait for plugin result for this task
+      const result = await new Promise((resolve, reject) => {
+        const timeoutMs = 3 * 60 * 1000; // 3 minutes
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+          timedOut = true;
+          project.pendingResults.delete(task.id);
+          reject(new Error("Command timed out: " + task.id));
+        }, timeoutMs);
+        project.pendingResults.set(task.id, {
+          resolve: (payload) => {
+            if (timedOut) return;
+            clearTimeout(timeout);
+            resolve(payload);
+          },
+          reject: (err) => {
+            if (timedOut) return;
+            clearTimeout(timeout);
+            reject(err);
+          }
         });
+      });
+      // If failure, mark and stop
+      if (result.status !== "ok") {
+        project.status = "failed";
+        throw new Error(`Command ${task.id} failed: ${result.message ?? "no message"}`);
       }
+      // If task had target_ref & plugin returned target_ref, map it
+      if (task.target_ref && result.target_ref) {
+        project._refs = project._refs || {};
+        project._refs[task.target_ref] = result.target_ref;
+      }
     }
+    project.status = "complete";
+  } catch (err) {
+    console.error("Project run error for", project.id, err);
+    if (project.status !== "failed") project.status = "error";
+  } finally {
+    project.running = false;
   }
+}
+app.listen(PORT, () => {
+  console.log(`BloxBuddy backend listening on port ${PORT}`);
+});