pixelforge-uploader 2.0.0

package/README.md

@@ -0,0 +1,52 @@
+# PixelForge Uploader
+
+A tiny local program that uploads [PixelForge](https://create.roblox.com) icons
+to Roblox through Open Cloud.
+
+## Why a separate program?
+
+Roblox Studio plugins can't upload assets on their own: `CreateAssetAsync` is
+blocked for Creator-Store installs, and `HttpService` can't reach
+`apis.roblox.com`. A plugin that uploads through a *remote* server gets removed
+for "Misusing Roblox Systems".
+
+So the plugin talks to this small program running on **your own machine**
+(`localhost`), and it does the upload from your own connection. Your API key
+lives only here, never in the plugin.
+
+## Run it
+
+Needs [Node.js](https://nodejs.org) 18+ (one-time install). Then, in a terminal:
+
+```
+npx pixelforge-uploader
+```
+
+The first time, it asks for your Open Cloud API key and creator id, then prints
+"PixelForge Uploader is running". Leave it open while you upload; close the
+window when you're done. Same command on Windows and macOS.
+
+## First-run setup
+
+It asks for:
+
+- **API key** - an Open Cloud key with the `asset:write` scope. Create one at
+  https://create.roblox.com/dashboard/credentials (add the "asset" API, check
+  `asset:write`, set IP Address to `0.0.0.0/0`).
+- **Creator** - upload to your account (user) or a group, and the numeric id.
+
+These are saved to `~/.pixelforge-uploader/config.json` (permissions 600). To
+change them later run `npx pixelforge-uploader reconfigure`, or set the env vars
+`PIXELFORGE_API_KEY`, `PIXELFORGE_CREATOR_TYPE`, `PIXELFORGE_CREATOR_ID`.
+
+## Use it
+
+1. Start it (`npx pixelforge-uploader`).
+2. In Studio, capture an icon in PixelForge and hit Upload.
+
+The plugin sends the raw pixels here; this app encodes the PNG, uploads it via
+Open Cloud, and hands the Image id back to the plugin. Default port `34890`
+(override with `PIXELFORGE_PORT`).
+
+No dependencies - plain Node `http`/`https`/`zlib`. Your API key only ever goes
+from this app directly to `apis.roblox.com`.

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "pixelforge-uploader",
+  "version": "2.0.0",
+  "description": "Local helper that uploads PixelForge icons to Roblox via Open Cloud. The Studio plugin sends raw pixels over localhost; this app holds the API key, encodes the PNG, and uploads.",
+  "license": "MIT",
+  "engines": { "node": ">=18" },
+  "main": "src.js",
+  "bin": { "pixelforge-uploader": "src.js" },
+  "files": ["src.js"],
+  "scripts": {
+    "start": "node src.js"
+  },
+  "dependencies": {}
+}

package/src.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+// PixelForge Uploader - local helper.
+//
+// A Creator-Store plugin can't upload an asset itself (no CreateAssetAsync, and
+// HttpService can't reach apis.roblox.com), and routing through a REMOTE proxy
+// gets it disabled for "Misusing Roblox Systems". But a plugin CAN talk to
+// localhost. So the plugin sends the captured image here and this app does
+// everything Roblox-related:
+// it holds the API key, encodes the PNG, and uploads via Open Cloud from the
+// user's own machine. The plugin itself stores no key and references no Roblox
+// API - it only POSTs raw pixels to localhost.
+//
+// Zero dependencies: plain Node http/https/zlib.
+//
+// Config (API key + creator) is collected once, interactively, and saved to
+//   ~/.pixelforge-uploader/config.json
+// (override with env PIXELFORGE_API_KEY / PIXELFORGE_CREATOR_TYPE /
+// PIXELFORGE_CREATOR_ID; re-run setup with `node src.js reconfigure`).
+//
+// Transport from the plugin:
+//   POST http://127.0.0.1:<PORT>/upload
+//     headers: x-pf-width, x-pf-height, x-pf-name (plain text)
+//     body:    raw RGBA bytes (width*height*4)
+//   -> 200 { imageId } | { error }
+//   GET /ping -> { ok, app, version, configured }
+
+const http = require("http");
+const https = require("https");
+const zlib = require("zlib");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+
+const PORT = Number(process.env.PIXELFORGE_PORT || process.argv[3] || 34890);
+const HOST = "127.0.0.1";
+const CONFIG_DIR = path.join(os.homedir(), ".pixelforge-uploader");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+const ASSETS_URL = "https://apis.roblox.com/assets/v1/assets";
+const OPERATION_URL = "https://apis.roblox.com/assets/v1/operations/";
+const POLL_INTERVAL_MS = 1500;
+const POLL_MAX_ATTEMPTS = 30;
+
+// ---------- config ----------
+
+function loadConfig() {
+	if (process.env.PIXELFORGE_API_KEY && process.env.PIXELFORGE_CREATOR_ID) {
+		return {
+			apiKey: process.env.PIXELFORGE_API_KEY,
+			creatorType: process.env.PIXELFORGE_CREATOR_TYPE === "group" ? "group" : "user",
+			creatorId: process.env.PIXELFORGE_CREATOR_ID,
+		};
+	}
+	try {
+		const c = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+		if (c && c.apiKey && c.creatorId) {
+			c.creatorType = c.creatorType === "group" ? "group" : "user";
+			return c;
+		}
+	} catch (_) {}
+	return null;
+}
+
+function saveConfig(cfg) {
+	fs.mkdirSync(CONFIG_DIR, { recursive: true });
+	fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
+
+function ask(rl, q) {
+	return new Promise((res) => rl.question(q, (a) => res(a.trim())));
+}
+
+async function runSetup() {
+	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+	console.log("\nPixelForge Uploader - first-time setup\n");
+	console.log("Create an Open Cloud API key at https://create.roblox.com/dashboard/credentials");
+	console.log("(add the \"asset\" API, check asset:write, set IP 0.0.0.0/0).\n");
+	const apiKey = await ask(rl, "Paste your API key: ");
+	let creatorType = (await ask(rl, "Upload to (1) your account or (2) a group? [1/2]: ")) === "2" ? "group" : "user";
+	const creatorId = await ask(rl, `Enter your ${creatorType === "group" ? "group" : "user"} id (number): `);
+	rl.close();
+	const cfg = { apiKey, creatorType, creatorId };
+	saveConfig(cfg);
+	console.log(`\nSaved to ${CONFIG_FILE}\n`);
+	return cfg;
+}
+
+// ---------- PNG encode (raw RGBA -> PNG, zlib) ----------
+
+let CRC_TABLE;
+function crc32(buf) {
+	if (!CRC_TABLE) {
+		CRC_TABLE = new Int32Array(256);
+		for (let n = 0; n < 256; n++) {
+			let c = n;
+			for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+			CRC_TABLE[n] = c;
+		}
+	}
+	let crc = -1;
+	for (let i = 0; i < buf.length; i++) crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ buf[i]) & 0xff];
+	return (crc ^ -1) >>> 0;
+}
+
+function pngChunk(type, data) {
+	const len = Buffer.alloc(4);
+	len.writeUInt32BE(data.length, 0);
+	const t = Buffer.from(type, "ascii");
+	const crc = Buffer.alloc(4);
+	crc.writeUInt32BE(crc32(Buffer.concat([t, data])), 0);
+	return Buffer.concat([len, t, data, crc]);
+}
+
+function encodePng(rgba, width, height) {
+	const stride = width * 4;
+	const raw = Buffer.alloc((stride + 1) * height);
+	for (let y = 0; y < height; y++) {
+		raw[y * (stride + 1)] = 0; // filter type 0 (none)
+		rgba.copy(raw, y * (stride + 1) + 1, y * stride, y * stride + stride);
+	}
+	const ihdr = Buffer.alloc(13);
+	ihdr.writeUInt32BE(width, 0);
+	ihdr.writeUInt32BE(height, 4);
+	ihdr[8] = 8;  // bit depth
+	ihdr[9] = 6;  // color type RGBA
+	return Buffer.concat([
+		Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+		pngChunk("IHDR", ihdr),
+		pngChunk("IDAT", zlib.deflateSync(raw, { level: 6 })),
+		pngChunk("IEND", Buffer.alloc(0)),
+	]);
+}
+
+// ---------- Open Cloud upload ----------
+
+function robloxRequest(method, url, headers, bodyBuffer) {
+	return new Promise((resolve, reject) => {
+		const u = new URL(url);
+		const req = https.request({ method, hostname: u.hostname, path: u.pathname + u.search, headers }, (resp) => {
+			const chunks = [];
+			resp.on("data", (c) => chunks.push(c));
+			resp.on("end", () => {
+				const raw = Buffer.concat(chunks).toString("utf8");
+				let json = null;
+				try { json = JSON.parse(raw); } catch (_) {}
+				resolve({ status: resp.statusCode, json, raw });
+			});
+		});
+		req.on("error", reject);
+		if (bodyBuffer) req.write(bodyBuffer);
+		req.end();
+	});
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function uploadImage(cfg, name, pngBuffer) {
+	const creator = cfg.creatorType === "group" ? { groupId: Number(cfg.creatorId) } : { userId: Number(cfg.creatorId) };
+	const meta = JSON.stringify({ assetType: "Image", displayName: name || "Icon", description: "Created with PixelForge", creationContext: { creator } });
+	const boundary = "----PixelForgeUploader" + Date.now().toString(16);
+	const CRLF = "\r\n";
+	const pre = Buffer.from(
+		`--${boundary}${CRLF}Content-Disposition: form-data; name="request"${CRLF}Content-Type: application/json${CRLF}${CRLF}${meta}${CRLF}` +
+		`--${boundary}${CRLF}Content-Disposition: form-data; name="fileContent"; filename="icon.png"${CRLF}Content-Type: image/png${CRLF}${CRLF}`, "utf8");
+	const body = Buffer.concat([pre, pngBuffer, Buffer.from(`${CRLF}--${boundary}--${CRLF}`, "utf8")]);
+
+	const post = await robloxRequest("POST", ASSETS_URL, {
+		"x-api-key": cfg.apiKey,
+		"Content-Type": "multipart/form-data; boundary=" + boundary,
+		"Content-Length": body.length,
+	}, body);
+
+	if (post.status === 401 || post.status === 403) {
+		throw new Error("API key rejected (HTTP " + post.status + "). Check asset:write and that it matches the creator.");
+	}
+	if (post.status !== 200 || !post.json) {
+		const detail = (post.json && (post.json.message || (post.json.error && post.json.error.message))) || post.raw.slice(0, 200);
+		throw new Error("Upload failed (HTTP " + post.status + "): " + detail);
+	}
+
+	const readId = (op) => {
+		if (!op || op.done !== true) return null;
+		if (op.error && op.error.message) throw new Error("Asset rejected: " + op.error.message);
+		return op.response && op.response.assetId != null ? String(op.response.assetId) : null;
+	};
+	let id = readId(post.json);
+	if (id) return id;
+	const opId = (post.json.path || "").match(/operations\/(.+)$/);
+	if (!opId) throw new Error("Upload accepted but no operation id returned.");
+	for (let i = 0; i < POLL_MAX_ATTEMPTS; i++) {
+		await sleep(POLL_INTERVAL_MS);
+		const poll = await robloxRequest("GET", OPERATION_URL + opId[1], { "x-api-key": cfg.apiKey });
+		if (poll.status === 200 && poll.json) {
+			id = readId(poll.json);
+			if (id) return id;
+		}
+	}
+	throw new Error("Timed out waiting for Roblox to finish processing the asset.");
+}
+
+// ---------- server ----------
+
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (c) => chunks.push(c));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+
+function json(res, status, obj) {
+	const b = JSON.stringify(obj);
+	res.writeHead(status, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(b), "Access-Control-Allow-Origin": "*" });
+	res.end(b);
+}
+
+function startServer(cfg) {
+	const server = http.createServer(async (req, res) => {
+		if (req.method === "GET" && req.url === "/ping") {
+			return json(res, 200, { ok: true, app: "PixelForge Uploader", version: "2", configured: !!cfg });
+		}
+		if (req.method === "POST" && req.url.startsWith("/upload")) {
+			try {
+				if (!cfg) return json(res, 400, { error: "Uploader not configured. Restart it and complete setup." });
+				const width = Number(req.headers["x-pf-width"]);
+				const height = Number(req.headers["x-pf-height"]);
+				const name = req.headers["x-pf-name"] || "Icon";
+				const rgba = await readBody(req);
+				if (!width || !height) return json(res, 400, { error: "Missing image dimensions." });
+				if (rgba.length !== width * height * 4) {
+					return json(res, 400, { error: `Pixel data is ${rgba.length} bytes, expected ${width * height * 4}.` });
+				}
+				console.log(`[upload] ${name} (${width}x${height}) -> ${cfg.creatorType} ${cfg.creatorId}`);
+				const png = encodePng(rgba, width, height);
+				const imageId = await uploadImage(cfg, name, png);
+				console.log(`[upload] done -> Image id ${imageId}`);
+				return json(res, 200, { imageId });
+			} catch (err) {
+				console.error("[upload] " + (err && err.message ? err.message : err));
+				return json(res, 502, { error: err && err.message ? err.message : String(err) });
+			}
+		}
+		json(res, 404, { error: "Not found" });
+	});
+
+	server.listen(PORT, HOST, () => {
+		console.log("=================================================");
+		console.log("  PixelForge Uploader is running.");
+		console.log("  Listening on http://localhost:" + PORT);
+		console.log("  Uploading to " + cfg.creatorType + " " + cfg.creatorId + ".");
+		console.log("  Leave this window open while you upload icons.");
+		console.log("=================================================");
+	});
+	server.on("error", (err) => {
+		if (err && err.code === "EADDRINUSE") {
+			console.error("Port " + PORT + " is already in use (another copy may be running).");
+		} else {
+			console.error("Server error:", err);
+		}
+		process.exit(1);
+	});
+}
+
+(async function main() {
+	let cfg = loadConfig();
+	if (process.argv[2] === "reconfigure" || !cfg) {
+		if (!cfg) console.log("No saved configuration found.");
+		cfg = await runSetup();
+	}
+	startServer(cfg);
+})();