Update app.js

app.js

@@ -1,327 +1,142 @@
 // 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
+// Node + Express server to accept Snapshotter payloads from the Roblox plugin.
+// Save as server.js and run: node server.js
+// Installs: npm install express body-parser cors
 
 import express from "express";
 import bodyParser from "body-parser";
 import cors from "cors";
-import { GoogleGenAI } from "@google/genai";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import fetch from "node-fetch"; // Node 18+ has fetch globally; if not, install node-fetch
 
-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);
-}
+// If you're running Node 18+, you can use global fetch and remove node-fetch import.
+// If you get "fetch is not defined", run: npm install node-fetch
+// and uncomment the import above (already present).
 
-const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
-const app = express();
-app.use(cors());
-app.use(bodyParser.json({ limit: "2mb" }));
-
-const projects = new Map();
-const simpleId = (prefix = "") => prefix + Math.random().toString(36).slice(2, 9);
-
-/**
- * STRICT VOCABULARY - Matched to Plugin
- */
-const VALID_ACTIONS = [
-  "create_part",
-  "create_model",
-  "create_meshpart",
-  "create_script",
-  "attach_script",
-  "edit_script",
-  "set_property",
-  "move_to",
-  "rotate_to",
-  "set_parent",
-  "delete",
-  "weld",
-  "list_workspace",
-  "finish"
-];
-
-const ACTION_SYNONYMS = {
-  "create_complex_mesh": "create_meshpart",
-  "load_mesh": "create_meshpart",
-  "move": "move_to",
-  "position": "move_to",
-  "rotate": "rotate_to",
-  "set_rotation": "rotate_to",
-  "add_script": "create_script",
-  "insert_script": "create_script",
-  "modify_script": "edit_script",
-  "append_script": "attach_script",
-  "group": "create_model", 
-  "parent": "set_parent",
-  "set_parent_to": "set_parent",
-  "join": "weld", 
-  "union": "create_model", 
-  "create_union": "create_model",
-  "create_rig": "create_model", 
-  "add_bone": "create_part" 
-};
-
-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.");
-
-    let actionRaw = String(t.action).trim();
-    const actionLower = actionRaw.toLowerCase();
-
-    let canonicalAction = null;
-    if (VALID_ACTIONS.includes(actionRaw)) canonicalAction = actionRaw;
-    if (!canonicalAction) {
-      canonicalAction = VALID_ACTIONS.find(a => a.toLowerCase() === actionLower) || null;
-    }
-    if (!canonicalAction && ACTION_SYNONYMS[actionLower]) {
-      canonicalAction = ACTION_SYNONYMS[actionLower];
-    }
-
-    if (!canonicalAction) {
-      throw new Error(`Invalid action '${actionRaw}'. Supported: ${VALID_ACTIONS.join(", ")}`);
-    }
-
-    const id = t.id || simpleId("cmd_");
-    const params = t.params && typeof t.params === "object" ? t.params : {};
-    return { id, action: canonicalAction, originalAction: actionRaw, params, target_ref: t.target_ref || null };
-  });
-}
-
-async function generateTasks(project) {
-  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,
-    originalAction: h.originalAction || null,
-    target_ref: h.target_ref || null,
-  }));
-  const refsKeys = Object.keys(project._refs || {}).slice(0, 200);
+const PORT = process.env.PORT ? Number(process.env.PORT) : 3000;
+const STORAGE_DIR = path.join(__dirname, "data");
 
-  const stateSummary = {
-    projectId: project.id,
-    refsSummary: refsKeys,
-    recentHistory: historySample
-  };
+if (!fs.existsSync(STORAGE_DIR)) fs.mkdirSync(STORAGE_DIR, { recursive: true });
 
-  const systemPrompt = `
-You are a precise Roblox Studio Assistant.
-Allowed actions: ${VALID_ACTIONS.join(", ")}.
-
-RULES:
-1. **References:** When creating an object, ALWAYS assign a unique "target_ref" (e.g., "ref_wall_1").
-2. **Chaining:** When moving/modifying later, use "target_ref": "ref_wall_1".
-3. **Hierarchy:** To put a Part inside a Model: create_model (ref_grp) -> create_part (ref_part) -> set_parent (target_ref: ref_part, params: { parent_ref: ref_grp }).
-4. **Math:** Use numbers. Position {x,y,z}. Rotation {x,y,z} (degrees).
-5. **Output:** Return ONLY a JSON Array.
-
-EXISTING STATE:
-${JSON.stringify(stateSummary, null, 2)}
-
-User Request:
-${JSON.stringify({ description: project.description })}
-`;
+const app = express();
+app.use(cors());
+app.use(bodyParser.json({ limit: "10mb" })); // Allow larger payloads (tweak as needed)
 
-  // Using 1.5-pro as the closest valid "Pro" model. 
-  // If you strictly need "gemini-2.5-pro", allow the string, but note it might 404 if not enabled on your account.
-  const resp = await ai.models.generateContent({
-    model: "gemini-2.5-pro", 
-    contents: systemPrompt,
-    generationConfig: { responseMimeType: "application/json" }
-  });
+// Simple logging middleware
+app.use((req, res, next) => {
+  console.log(new Date().toISOString(), req.method, req.url);
+  next();
+});
 
-  // === FIX: Robust Response Text Extraction ===
-  let text = "";
-  if (resp && typeof resp.text === 'string') {
-     // SDK returned text property directly
-     text = resp.text; 
-  } else if (resp && typeof resp.text === 'function') {
-     // SDK returned text method
-     text = resp.text();
-  } else if (resp?.response?.text) {
-     // Nested response object
-     text = typeof resp.response.text === 'function' ? resp.response.text() : resp.response.text;
-  } else {
-     // Fallback for raw data structure
-     text = resp?.data?.candidates?.[0]?.content?.parts?.[0]?.text || "";
-  }
-  // ============================================
+// Simple health/ping
+app.get("/ping", (req, res) => res.status(200).send("pong"));
 
-  let arr;
+// Compatibility endpoint from your older plugin code
+app.post("/capture-and-upload", async (req, res) => {
   try {
-    // Sanitize markdown if still present
-    const cleanText = text.replace(/```json/g, "").replace(/```/g, "").trim();
-    arr = JSON.parse(cleanText);
-  } catch (err) {
-    // Fallback extraction
-    const start = text.indexOf("[");
-    const end = text.lastIndexOf("]");
-    if (start >= 0 && end > start) {
-      arr = JSON.parse(text.slice(start, end + 1));
-    } else {
-      console.error("AI Output was:", text);
-      throw new Error("Could not parse JSON from model output.");
+    const payload = req.body;
+    if (!payload) return res.status(400).json({ success: false, error: "empty payload" });
+
+    // generate an id and save payload to disk
+    const id = "asset_" + Math.random().toString(36).slice(2, 10);
+    const filename = path.join(STORAGE_DIR, `${id}.json`);
+    fs.writeFileSync(filename, JSON.stringify({ receivedAt: Date.now(), payload }, null, 2), "utf8");
+
+    // Optionally perform immediate processing here (call AI service, upload images...).
+    // For this demo we simply accept and return an assetId.
+
+    // If client asked for a callbackUrl, try to POST back a small completion message
+    if (payload.callbackUrl && typeof payload.callbackUrl === "string") {
+      const cbBody = { assetId: id, status: "processed", ts: Date.now() };
+      // fire-and-forget; do not block the main response on callback success
+      (async () => {
+        try {
+          // Use fetch if available
+          if (typeof fetch === "function") {
+            const r = await fetch(payload.callbackUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(cbBody),
+              timeout: 10000
+            });
+            console.log("Callback posted, status:", r.status);
+          } else {
+            console.log("No fetch available to call callback URL.");
+          }
+        } catch (err) {
+          console.warn("Callback POST failed:", err && err.message ? err.message : err);
+        }
+      })();
     }
-  }
-
-  return validateAndPrepareTasks(arr);
-}
-
-// --- ENDPOINTS ---
-
-app.post("/projects", async (req, res) => {
-  try {
-    const projectId = req.body.projectId || simpleId("proj_");
-    const project = {
-      id: projectId,
-      description: req.body.description || "New Project",
-      status: "queued",
-      tasks: [],
-      commandQueue: [],
-      pendingResults: new Map(),
-      running: false,
-      history: [], 
-      _refs: {}    
-    };
 
-    projects.set(projectId, project);
-
-    runProject(project).catch((err) => {
-      project.status = "error";
-      console.error("runProject error:", err);
-    });
-
-    return res.status(202).json({ projectId, status: "accepted" });
+    return res.json({ success: true, assetId: id });
   } catch (err) {
-    return res.status(500).json({ error: err.message });
+    console.error("capture-and-upload error:", err);
+    return res.status(500).json({ success: false, error: String(err) });
   }
 });
 
-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;
-  project.description += `\nUser Update: ${prompt}`;
-
+// New route name used in the plugin snippet: /api/ai-build
+app.post("/api/ai-build", async (req, res) => {
   try {
-    const newTasks = await generateTasks({ ...project, description: prompt });
-    project.tasks.push(...newTasks);
-    project.commandQueue.push(...newTasks);
-    return res.json({ appended: newTasks.length, tasks: newTasks });
-  } catch (err) {
-    return res.status(500).json({ error: err.message });
-  }
-});
-
-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) {
-    return res.json(project.commandQueue.shift());
-  }
-  return res.status(204).end();
-});
-
-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;
-  
-  // History recording
-  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);
-
-  if (target_ref && status === "ok") {
-    project._refs = project._refs || {};
-    project._refs[target_ref] = { commandId, ts: Date.now() };
-  }
+    const payload = req.body;
+    if (!payload) return res.status(400).json({ success: false, error: "empty payload" });
+
+    // Save payload to disk
+    const id = "asset_" + Math.random().toString(36).slice(2, 10);
+    const filename = path.join(STORAGE_DIR, `${id}.json`);
+    fs.writeFileSync(filename, JSON.stringify({ receivedAt: Date.now(), payload }, null, 2), "utf8");
+
+    // (Here you could call the Gemini API, save images, run processing, etc.)
+    // For now we immediately return success with the generated asset id.
+
+    // If payload provides callbackUrl, POST a callback (fire-and-forget)
+    if (payload.callbackUrl && typeof payload.callbackUrl === "string") {
+      const cbBody = { assetId: id, status: "processed", ts: Date.now() };
+      (async () => {
+        try {
+          if (typeof fetch === "function") {
+            await fetch(payload.callbackUrl, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(cbBody)
+            });
+            console.log("Callback sent to", payload.callbackUrl);
+          }
+        } catch (err) {
+          console.warn("Callback failed:", err && err.message ? err.message : err);
+        }
+      })();
+    }
 
-  const waiter = project.pendingResults.get(commandId);
-  if (waiter) {
-    project.pendingResults.delete(commandId);
-    waiter.resolve({ status, message, target_ref });
-    return res.json({ ok: true });
+    return res.json({ success: true, assetId: id, message: "received" });
+  } catch (err) {
+    console.error("/api/ai-build error:", err);
+    return res.status(500).json({ success: false, error: String(err) });
   }
-
-  return res.json({ ok: true });
 });
 
-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,
-    queued: project.commandQueue.length,
-    refs: project._refs || {}
-  });
-});
-
-async function runProject(project) {
-  if (project.running) return;
-  project.running = true;
-  project.status = "running";
-
+// Optional: status endpoint for an asset (reads saved JSON)
+app.get("/asset/:id", (req, res) => {
   try {
-    if (!project.tasks || project.tasks.length === 0) {
-      project.tasks = await generateTasks(project);
-    }
-    project.commandQueue.push(...project.tasks);
-
-    // Blocking wait logic
-    for (const task of project.tasks) {
-      const result = await new Promise((resolve, reject) => {
-        const timeoutMs = 3 * 60 * 1000; 
-        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 (result.status !== "ok") {
-        project.status = "failed";
-        throw new Error(`Command ${task.id} failed: ${result.message}`);
-      }
-    }
-    project.status = "complete";
+    const id = req.params.id;
+    const filename = path.join(STORAGE_DIR, `${id}.json`);
+    if (!fs.existsSync(filename)) return res.status(404).json({ found: false });
+    const content = fs.readFileSync(filename, "utf8");
+    return res.json({ found: true, data: JSON.parse(content) });
   } catch (err) {
-    console.error("Project run error:", err);
-    if (project.status !== "failed") project.status = "error";
-  } finally {
-    project.running = false;
+    console.error("/asset error", err);
+    return res.status(500).json({ success: false, error: String(err) });
   }
-}
+});
 
+// Start server
 app.listen(PORT, () => {
-  console.log(`BloxBuddy backend listening on port ${PORT}`);
+  console.log(`Plugin backend listening on http://localhost:${PORT}`);
+  console.log("Saved payloads will be stored in:", STORAGE_DIR);
 });