-
{label}
+
+
+ {label}
+ {actionButton ? (
+
+ ) : null}
+
)
diff --git a/web/src/e2e/app.spec.ts b/web/src/e2e/app.spec.ts
index c93089f..0f9be96 100644
--- a/web/src/e2e/app.spec.ts
+++ b/web/src/e2e/app.spec.ts
@@ -19,3 +19,17 @@ test("loads under the GitHub Pages base and obfuscates input", async ({ page })
const download = await downloadPromise
expect(download.suggestedFilename()).toBe("prometheus.obfuscated.lua")
})
+
+test("runs input script and shows logs", async ({ page }) => {
+ await page.goto("/")
+ await expect(page.getByRole("heading", { name: "Prometheus Web" })).toBeVisible()
+
+ const input = page.getByLabel("Lua input").locator(".cm-content")
+ await input.click()
+ await page.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A")
+ await page.keyboard.type('print("Run works")')
+
+ await page.getByLabel("Lua input").getByRole("button", { name: "Run" }).click()
+ await expect(page.getByText("Script execution complete")).toBeVisible({ timeout: 30000 })
+ await expect(page.getByText("Run works")).toBeVisible()
+})
diff --git a/web/src/lib/prometheusTypes.ts b/web/src/lib/prometheusTypes.ts
index 556778c..61c9032 100644
--- a/web/src/lib/prometheusTypes.ts
+++ b/web/src/lib/prometheusTypes.ts
@@ -33,12 +33,27 @@ export interface PrometheusFailure {
export type PrometheusResult = PrometheusSuccess | PrometheusFailure
-export interface WorkerRequest {
- id: number
- options: PrometheusOptions
-}
-
-export interface WorkerResponse {
- id: number
- result: PrometheusResult
-}
+export type WorkerRequest =
+ | {
+ id: number
+ action: "obfuscate"
+ options: PrometheusOptions
+ }
+ | {
+ id: number
+ action: "runScript"
+ source: string
+ filename: string
+ }
+
+export type WorkerResponse =
+ | {
+ id: number
+ type: "result"
+ result: PrometheusResult
+ }
+ | {
+ id: number
+ type: "log"
+ log: PrometheusLog
+ }
diff --git a/web/src/worker/prometheus.worker.ts b/web/src/worker/prometheus.worker.ts
index 25c1934..f230726 100644
--- a/web/src/worker/prometheus.worker.ts
+++ b/web/src/worker/prometheus.worker.ts
@@ -1,22 +1,34 @@
import type { WorkerRequest, WorkerResponse } from "@/lib/prometheusTypes"
type RunPrometheus = typeof import("./prometheusRunner")["runPrometheus"]
+type RunLuaScript = typeof import("./prometheusRunner")["runLuaScript"]
let runPrometheus: RunPrometheus | null = null
+let runLuaScript: RunLuaScript | null = null
-async function getRunPrometheus(): Promise
{
- if (runPrometheus) {
- return runPrometheus
- }
-
+async function loadRunner() {
const module = await import("./prometheusRunner")
- runPrometheus = module.runPrometheus
- return runPrometheus
+ runPrometheus ??= module.runPrometheus
+ runLuaScript ??= module.runLuaScript
+ return { runPrometheus, runLuaScript }
}
self.onmessage = async (event: MessageEvent) => {
- const { id, options } = event.data
- const result = await getRunPrometheus()
- .then((execute) => execute(options))
+ const request = event.data
+
+ const result = await loadRunner()
+ .then(({ runPrometheus: doObfuscate, runLuaScript: doRun }) => {
+ if (request.action === "obfuscate") {
+ return doObfuscate(request.options)
+ }
+
+ return doRun(
+ { source: request.source, filename: request.filename },
+ (log) => {
+ const logResponse: WorkerResponse = { id: request.id, type: "log", log }
+ self.postMessage(logResponse)
+ },
+ )
+ })
.catch((error) => ({
ok: false as const,
error:
@@ -26,6 +38,6 @@ self.onmessage = async (event: MessageEvent) => {
logs: [],
}))
- const response: WorkerResponse = { id, result }
+ const response: WorkerResponse = { id: request.id, type: "result", result }
self.postMessage(response)
}
diff --git a/web/src/worker/prometheusRunner.ts b/web/src/worker/prometheusRunner.ts
index abd7928..d80a401 100644
--- a/web/src/worker/prometheusRunner.ts
+++ b/web/src/worker/prometheusRunner.ts
@@ -57,11 +57,15 @@ _G.arg = _G.arg or {}
${bootstrapLua}
local logs = {}
+local unpackFn = table.unpack or unpack
local function pushLog(level, ...)
local parts = {}
for i = 1, select("#", ...) do
parts[#parts + 1] = tostring(select(i, ...))
end
+ if type(_G.__prometheusPushLog) == "function" then
+ _G.__prometheusPushLog(level, unpackFn(parts))
+ end
logs[#logs + 1] = { level = level, message = table.concat(parts, " ") }
end
@@ -108,6 +112,46 @@ return { ok = ok, output = ok and outputOrError or "", error = ok and "" or outp
`
}
+interface LuaScriptOptions {
+ source: string
+ filename: string
+}
+
+export function buildScriptRunLua(options: LuaScriptOptions): string {
+ return `
+local logs = {}
+local unpackFn = table.unpack or unpack
+local function pushLog(level, ...)
+ local parts = {}
+ for i = 1, select("#", ...) do
+ parts[#parts + 1] = tostring(select(i, ...))
+ end
+ if type(_G.__prometheusPushLog) == "function" then
+ _G.__prometheusPushLog(level, unpackFn(parts))
+ end
+ logs[#logs + 1] = { level = level, message = table.concat(parts, " ") }
+end
+
+print = function(...)
+ pushLog("info", ...)
+end
+
+local ok, err = xpcall(function()
+ local chunk, loadErr = load(${toLuaLongString(options.source)}, ${toLuaLongString(options.filename)}, "t")
+ if not chunk then
+ error(loadErr)
+ end
+ chunk()
+end, debug.traceback)
+
+if not ok then
+ pushLog("error", err)
+end
+
+return { ok = ok, output = "", error = ok and "" or err, logs = logs }
+`
+}
+
function normalizeLogs(logs: unknown): PrometheusLog[] {
if (!Array.isArray(logs)) {
return []
@@ -157,3 +201,51 @@ export async function runPrometheus(options: PrometheusOptions): Promise void,
+): Promise {
+ let lua: Awaited["createEngine"]>> | null = null
+
+ try {
+ const LuaFactory = await getLuaFactoryConstructor()
+ lua = await new LuaFactory(glueWasmUrl).createEngine({ openStandardLibs: true })
+ if (onLog) {
+ const luaGlobal = lua.global as unknown as {
+ set?: (name: string, value: (...args: unknown[]) => void) => void
+ }
+ luaGlobal.set?.("__prometheusPushLog", (level: unknown, ...parts: unknown[]) => {
+ const normalized: PrometheusLog = {
+ level: level === "warn" || level === "error" || level === "debug" ? level : "info",
+ message: parts.map((part) => String(part)).join(" "),
+ }
+ onLog(normalized)
+ })
+ }
+
+ const result = (await lua.doString(buildScriptRunLua(options))) as {
+ ok?: unknown
+ output?: unknown
+ error?: unknown
+ logs?: unknown
+ }
+ if (result.ok === false) {
+ return {
+ ok: false,
+ error: String(result.error ?? "Script execution failed"),
+ logs: normalizeLogs(result.logs),
+ }
+ }
+
+ return { ok: true, output: String(result.output ?? ""), logs: normalizeLogs(result.logs) }
+ } catch (error) {
+ return {
+ ok: false,
+ error: error instanceof Error ? error.message : String(error),
+ logs: [],
+ }
+ } finally {
+ lua?.global.close()
+ }
+}
From 1030d448d8056454e952446c8b22f9838ffc5320 Mon Sep 17 00:00:00 2001
From: Elias Oelschner <62939318+levno-710@users.noreply.github.com>
Date: Fri, 8 May 2026 13:45:12 +0200
Subject: [PATCH 3/9] add share-link functionality
---
web/src/App.tsx | 367 ++++++++++++++++++++++++++++++----------
web/src/e2e/app.spec.ts | 53 ++++++
web/vite.config.ts | 3 +-
3 files changed, 331 insertions(+), 92 deletions(-)
diff --git a/web/src/App.tsx b/web/src/App.tsx
index 051ced6..b62d427 100644
--- a/web/src/App.tsx
+++ b/web/src/App.tsx
@@ -1,4 +1,4 @@
-import { Check, Copy, Download, FileCode2, Github, Loader2, Play, RotateCcw, Square } from "lucide-react"
+import { Check, Copy, Download, FileCode2, Github, Loader2, Play, RotateCcw, Share2, Square } from "lucide-react"
import { useEffect, useRef, useState } from "react"
import { toast } from "sonner"
@@ -29,6 +29,16 @@ print(message)
const WORKER_TIMEOUT_MS = 90_000
type ActiveJob = "idle" | "obfuscate" | "run-input" | "run-output"
+type SharePayload = {
+ version: 1
+ source: string
+ preset: PresetName
+ luaVersion: LuaVersion
+ prettyPrint: boolean
+ seed: number
+ outputHash: string | null
+}
+type LastObfuscation = Omit
function createSeed() {
return Math.floor(crypto.getRandomValues(new Uint32Array(1))[0] % 2147483646) + 1
@@ -56,6 +66,42 @@ function formatWorkerError(event: ErrorEvent): string {
return `${detail}${location}`
}
+function encodeBase64Url(input: string): string {
+ const bytes = new TextEncoder().encode(input)
+ let binary = ""
+ for (const byte of bytes) {
+ binary += String.fromCharCode(byte)
+ }
+ return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "")
+}
+
+function decodeBase64Url(input: string): string {
+ const normalized = input.replace(/-/g, "+").replace(/_/g, "/")
+ const padding = "=".repeat((4 - (normalized.length % 4)) % 4)
+ const binary = atob(normalized + padding)
+ const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0))
+ return new TextDecoder().decode(bytes)
+}
+
+function fallbackHash(input: string): string {
+ // FNV-1a 32-bit fallback for environments where SubtleCrypto is unavailable.
+ let hash = 0x811c9dc5
+ for (let i = 0; i < input.length; i += 1) {
+ hash ^= input.charCodeAt(i)
+ hash = Math.imul(hash, 0x01000193)
+ }
+ return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`
+}
+
+async function sha256Hex(input: string): Promise {
+ if (!crypto.subtle) {
+ return fallbackHash(input)
+ }
+ const bytes = new TextEncoder().encode(input)
+ const digest = await crypto.subtle.digest("SHA-256", bytes)
+ return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+}
+
export default function App() {
const [source, setSource] = useState(initialSource)
const [output, setOutput] = useState("")
@@ -66,9 +112,19 @@ export default function App() {
const [logs, setLogs] = useState([])
const [activeJob, setActiveJob] = useState("idle")
const [copied, setCopied] = useState(false)
+ const [lastObfuscation, setLastObfuscation] = useState(null)
const workerRef = useRef(null)
const requestIdRef = useRef(0)
const workerUrlRef = useRef("")
+ const autoShareLoadedRef = useRef(false)
+ const pendingWorkerRejectsRef = useRef(new Set<(error: Error) => void>())
+
+ function rejectPendingWorkerRequests(message: string) {
+ for (const reject of pendingWorkerRejectsRef.current) {
+ reject(new Error(message))
+ }
+ pendingWorkerRejectsRef.current.clear()
+ }
function setupWorker(worker: Worker) {
worker.addEventListener("error", (event: Event) => {
@@ -76,6 +132,7 @@ export default function App() {
const detail = formatWorkerError(errorEvent)
console.error("Prometheus worker error event:", event)
console.error("Prometheus worker detail:", detail)
+ rejectPendingWorkerRequests(detail)
setActiveJob("idle")
setLogs((current) => [...current, { level: "error", message: detail }])
toast.error("Worker error")
@@ -85,6 +142,7 @@ export default function App() {
worker.addEventListener("messageerror", (event) => {
console.error("Prometheus worker message error:", event)
+ rejectPendingWorkerRequests("Worker message decode failed.")
setActiveJob("idle")
setLogs((current) => [...current, { level: "error", message: "Worker message decode failed." }])
toast.error("Worker message error")
@@ -93,32 +151,6 @@ export default function App() {
})
}
- async function canLoadWorker(workerUrl: string): Promise<{ ok: boolean; message?: string }> {
- if (window.location.protocol === "file:") {
- return {
- ok: false,
- message:
- "Worker cannot run from file://. Serve the app over http:// or https:// (for example with `pnpm --filter web dev` or `pnpm --filter web preview`).",
- }
- }
-
- try {
- const response = await fetch(workerUrl, { method: "GET", cache: "no-store" })
- if (!response.ok) {
- return {
- ok: false,
- message: `Worker script request failed: ${response.status} ${response.statusText} (${workerUrl})`,
- }
- }
- return { ok: true }
- } catch (error) {
- return {
- ok: false,
- message: `Worker script request threw: ${error instanceof Error ? error.message : String(error)} (${workerUrl})`,
- }
- }
- }
-
function createWorker() {
const worker = new Worker(new URL("./worker/prometheus.worker.ts", import.meta.url), {
type: "module",
@@ -133,6 +165,7 @@ export default function App() {
return
}
+ rejectPendingWorkerRequests("Execution stopped by user.")
workerRef.current?.terminate()
workerRef.current = null
createWorker()
@@ -159,91 +192,180 @@ export default function App() {
const isRunningOutput = activeJob === "run-output"
async function sendWorkerRequest(request: WorkerRequest): Promise {
- let worker = workerRef.current
- const workerUrl =
- workerUrlRef.current || new URL("./worker/prometheus.worker.ts", import.meta.url).toString()
- const preflight = await canLoadWorker(workerUrl)
- if (!preflight.ok) {
- setActiveJob("idle")
- return {
- ok: false,
- error: preflight.message ?? "Worker preflight failed.",
- logs: [],
+ try {
+ let worker = workerRef.current
+ if (window.location.protocol === "file:") {
+ return {
+ ok: false,
+ error:
+ "Worker cannot run from file://. Serve the app over http:// or https:// (for example with `pnpm --filter web dev` or `pnpm --filter web preview`).",
+ logs: [],
+ }
}
- }
-
- if (!worker) {
- worker = createWorker()
- }
- return new Promise((resolve, reject) => {
- const timeout = window.setTimeout(() => {
- worker?.removeEventListener("message", listener)
- reject(new Error("Worker timed out before returning a result."))
- }, WORKER_TIMEOUT_MS)
+ if (!worker) {
+ worker = createWorker()
+ }
- const listener = (event: MessageEvent) => {
- const response = event.data
- if (response.id !== request.id) {
- return
+ return new Promise((resolve, reject) => {
+ let settled = false
+ const settle = (callback: () => void) => {
+ if (settled) {
+ return
+ }
+ settled = true
+ window.clearTimeout(timeout)
+ worker?.removeEventListener("message", listener)
+ pendingWorkerRejectsRef.current.delete(rejectRequest)
+ callback()
}
- if (response.type === "log") {
- setLogs((current) => [...current, response.log])
- return
+ const rejectRequest = (error: Error) => settle(() => reject(error))
+ const timeout = window.setTimeout(() => {
+ rejectRequest(new Error("Worker timed out before returning a result."))
+ }, WORKER_TIMEOUT_MS)
+
+ const listener = (event: MessageEvent) => {
+ const response = event.data
+ if (response.id !== request.id) {
+ return
+ }
+ if (response.type === "log") {
+ setLogs((current) => [...current, response.log])
+ return
+ }
+ if (response.type !== "result") {
+ return
+ }
+ settle(() => resolve(response.result))
}
- if (response.type !== "result") {
- return
+ pendingWorkerRejectsRef.current.add(rejectRequest)
+ worker?.addEventListener("message", listener)
+ worker?.postMessage(request)
+ }).catch((error): PrometheusResult => {
+ return {
+ ok: false,
+ error: error instanceof Error ? error.message : String(error),
+ logs: [],
}
- window.clearTimeout(timeout)
- worker?.removeEventListener("message", listener)
- resolve(response.result)
- }
- worker?.addEventListener("message", listener)
- worker?.postMessage(request)
- }).catch((error): PrometheusResult => {
+ })
+ } catch (error) {
return {
ok: false,
error: error instanceof Error ? error.message : String(error),
logs: [],
}
- })
+ }
}
- async function obfuscate() {
- if (isBusy) {
+ async function obfuscate(override?: {
+ sharedOutputHash?: string | null
+ options?: {
+ source: string
+ preset: PresetName
+ luaVersion: LuaVersion
+ prettyPrint: boolean
+ seed: number
+ }
+ }) {
+ if (isBusy && !override) {
return
}
setActiveJob("obfuscate")
- setLogs([])
- const id = ++requestIdRef.current
- const request: WorkerRequest = {
- id,
- action: "obfuscate",
- options: {
- source,
- filename: "browser-input.lua",
- preset,
- luaVersion,
- prettyPrint,
- seed,
- },
- }
+ try {
+ setLogs([])
+ const id = ++requestIdRef.current
+ const options = override?.options ?? { source, preset, luaVersion, prettyPrint, seed }
+ const request: WorkerRequest = {
+ id,
+ action: "obfuscate",
+ options: {
+ source: options.source,
+ filename: "browser-input.lua",
+ preset: options.preset,
+ luaVersion: options.luaVersion,
+ prettyPrint: options.prettyPrint,
+ seed: options.seed,
+ },
+ }
- const result = await sendWorkerRequest(request)
- setActiveJob("idle")
- setLogs(result.logs)
+ const result = await sendWorkerRequest(request)
+ setLogs(result.logs)
+
+ if (result.ok) {
+ const outputHash = await sha256Hex(result.output)
+ setLastObfuscation({
+ source: options.source,
+ preset: options.preset,
+ luaVersion: options.luaVersion,
+ prettyPrint: options.prettyPrint,
+ seed: options.seed,
+ outputHash,
+ })
+ setOutput(result.output)
+ setSeed(createSeed())
+ if (typeof override?.sharedOutputHash === "string") {
+ if (outputHash !== override.sharedOutputHash) {
+ setOutput("")
+ setLogs((current) => [
+ ...current,
+ {
+ level: "error",
+ message:
+ "This shared link was generated using an older version of Prometheus and no longer produces the intended obfuscated result.",
+ },
+ ])
+ toast.error("Shared link hash mismatch")
+ return
+ }
+ toast.success("Shared link loaded")
+ return
+ }
+ toast.success("Obfuscation complete")
+ return
+ }
- if (result.ok) {
- setOutput(result.output)
- setSeed(createSeed())
- toast.success("Obfuscation complete")
+ setLastObfuscation({
+ source: options.source,
+ preset: options.preset,
+ luaVersion: options.luaVersion,
+ prettyPrint: options.prettyPrint,
+ seed: options.seed,
+ outputHash: null,
+ })
+ setOutput("")
+ setLogs([...result.logs, { level: "error", message: result.error }])
+ toast.error("Obfuscation failed")
+ } catch (error) {
+ const message = error instanceof Error ? error.message : String(error)
+ setOutput("")
+ setLogs((current) => [...current, { level: "error", message }])
+ toast.error("Obfuscation failed")
+ } finally {
+ setActiveJob("idle")
+ }
+ }
+
+ async function shareLink() {
+ if (!lastObfuscation) {
return
}
- setOutput("")
- setLogs([...result.logs, { level: "error", message: result.error }])
- toast.error("Obfuscation failed")
+ const payload: SharePayload = {
+ version: 1,
+ source: lastObfuscation.source,
+ preset: lastObfuscation.preset,
+ luaVersion: lastObfuscation.luaVersion,
+ prettyPrint: lastObfuscation.prettyPrint,
+ seed: lastObfuscation.seed,
+ outputHash: lastObfuscation.outputHash,
+ }
+ const encoded = encodeBase64Url(JSON.stringify(payload))
+ const shareUrl = new URL(window.location.href)
+ shareUrl.searchParams.set("share", encoded)
+ window.history.replaceState({}, "", shareUrl)
+ await navigator.clipboard.writeText(shareUrl.toString())
+ toast.success("Share link copied")
}
async function runScript(kind: "input" | "output") {
@@ -297,6 +419,61 @@ export default function App() {
window.setTimeout(() => setCopied(false), 1200)
}
+ useEffect(() => {
+ if (autoShareLoadedRef.current || isBusy) {
+ return
+ }
+
+ const encoded = new URL(window.location.href).searchParams.get("share")
+ if (!encoded) {
+ return
+ }
+
+ const timeout = window.setTimeout(() => {
+ autoShareLoadedRef.current = true
+ let payload: SharePayload | null = null
+ try {
+ payload = JSON.parse(decodeBase64Url(encoded)) as SharePayload
+ } catch {
+ setLogs([{ level: "error", message: "Invalid shared link payload." }])
+ toast.error("Invalid shared link")
+ return
+ }
+
+ if (
+ payload.version !== 1 ||
+ !PRESETS.includes(payload.preset) ||
+ !LUA_VERSIONS.includes(payload.luaVersion) ||
+ typeof payload.source !== "string" ||
+ typeof payload.prettyPrint !== "boolean" ||
+ typeof payload.seed !== "number" ||
+ (typeof payload.outputHash !== "string" && payload.outputHash !== null)
+ ) {
+ setLogs([{ level: "error", message: "Invalid shared link payload." }])
+ toast.error("Invalid shared link")
+ return
+ }
+
+ setSource(payload.source)
+ setPreset(payload.preset)
+ setLuaVersion(payload.luaVersion)
+ setPrettyPrint(payload.prettyPrint)
+ setSeed(Math.max(1, Math.floor(payload.seed)))
+ void obfuscate({
+ sharedOutputHash: payload.outputHash,
+ options: {
+ source: payload.source,
+ preset: payload.preset,
+ luaVersion: payload.luaVersion,
+ prettyPrint: payload.prettyPrint,
+ seed: payload.seed,
+ },
+ })
+ }, 0)
+
+ return () => window.clearTimeout(timeout)
+ }, [isBusy])
+
return (
@@ -324,7 +501,7 @@ export default function App() {
GitHub
- 
+ 