Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,4 @@ node_modules/monaco-editor/dev/vs/editor/editor.main.js.map filter=lfs diff=lfs
 node_modules/monaco-editor/dev/vs/language/typescript/tsWorker.js filter=lfs diff=lfs merge=lfs -text
 node_modules/monaco-editor/esm/vs/language/typescript/ts.worker.js filter=lfs diff=lfs merge=lfs -text
 node_modules/monaco-editor/min-maps/vs/editor/editor.main.js.map filter=lfs diff=lfs merge=lfs -text
+public/osws-demo.gif filter=lfs diff=lfs merge=lfs -text

package.json

@@ -0,0 +1,87 @@
+{
+  "name": "osw-studio-v1",
+  "version": "1.84.0",
+  "private": true,
+  "license": "MIT",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "postinstall": "cp node_modules/esbuild-wasm/esbuild.wasm public/esbuild.wasm 2>/dev/null || true"
+  },
+  "dependencies": {
+    "@huggingface/hub": "^2.9.0",
+    "@jitl/quickjs-wasmfile-release-sync": "^0.31.0",
+    "@monaco-editor/react": "^4.7.0-rc.0",
+    "@mozilla/readability": "^0.6.0",
+    "@radix-ui/react-checkbox": "^1.3.3",
+    "@radix-ui/react-collapsible": "^1.1.11",
+    "@radix-ui/react-context-menu": "^2.2.15",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-dropdown-menu": "^2.1.15",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-popover": "^1.1.14",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-switch": "^1.2.5",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-toggle-group": "^1.1.11",
+    "@radix-ui/react-tooltip": "^1.2.7",
+    "@tailwindcss/postcss": "^4.1.12",
+    "@tanstack/react-query": "^5.80.6",
+    "@types/node": "20.19.11",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "bcrypt": "^6.0.0",
+    "better-sqlite3": "^11.7.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cron-parser": "^4.9.0",
+    "date-fns": "^4.1.0",
+    "esbuild-wasm": "^0.24.0",
+    "handlebars": "^4.7.8",
+    "html2canvas": "^1.4.1",
+    "jose": "^6.1.0",
+    "jszip": "^3.10.1",
+    "lucide-react": "^0.513.0",
+    "lz-string": "^1.5.0",
+    "monaco-editor": "^0.52.2",
+    "next": "^15.5.9",
+    "next-themes": "^0.4.6",
+    "postcss": "^8",
+    "quickjs-emscripten": "^0.31.0",
+    "quickjs-emscripten-core": "^0.31.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-markdown": "^10.1.0",
+    "react-resizable-panels": "^3.0.4",
+    "remark-gfm": "^4.0.1",
+    "server-only": "^0.0.1",
+    "sonner": "^2.0.5",
+    "tailwind-merge": "^3.3.0",
+    "tailwindcss": "^4",
+    "turndown": "^7.2.4",
+    "typescript": "5.9.2",
+    "uuid": "^11.1.0",
+    "zustand": "^5.0.13"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3",
+    "@playwright/test": "^1.60.0",
+    "@types/bcrypt": "^6.0.0",
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/lz-string": "^1.3.34",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@types/turndown": "^5.0.6",
+    "@types/uuid": "^10.0.0",
+    "eslint": "^9.39.2",
+    "eslint-config-next": "^15.5.19",
+    "fake-indexeddb": "^6.2.5",
+    "jsdom": "^27.0.1",
+    "vitest": "^3.2.4"
+  }
+}

postcss.config.mjs

@@ -0,0 +1,5 @@
+const config = {
+  plugins: ["@tailwindcss/postcss"],
+};
+
+export default config;

public/esbuild.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2b4b98297e04ef12981bafabf0a3c2d7c3c5cf6af603ef79d886deac3b5eeb3
+size 11907565

public/workers/script-worker.js

@@ -0,0 +1,247 @@
+/**
+ * Script Worker — Executes Python (Pyodide) and Lua (wasmoon) scripts
+ * in a Web Worker to avoid blocking the UI thread.
+ *
+ * Receives: { type: 'execute', payload: { runtime, entryPoint, files } }
+ *           { type: 'abort' }
+ * Posts:    { type: 'stdout'|'stderr'|'status'|'error'|'complete'|'output-file', ... }
+ */
+
+/* global self, importScripts, postMessage */
+
+let pyodide = null;
+let luaFactory = null;
+
+/**
+ * Post a message back to the main thread.
+ */
+function send(type, data) {
+  self.postMessage({ type, data });
+}
+
+function sendFile(path, content) {
+  self.postMessage({ type: 'output-file', path, content });
+}
+
+// ─── Python (Pyodide) ──────────────────────────────────────────────
+
+async function ensurePyodide() {
+  if (pyodide) return pyodide;
+
+  send('status', 'Loading Python runtime...');
+
+  try {
+    importScripts('https://cdn.jsdelivr.net/pyodide/v0.27.4/full/pyodide.js');
+  } catch (err) {
+    send('error', 'Failed to load Pyodide from CDN: ' + String(err));
+    throw err;
+  }
+
+  try {
+    pyodide = await self.loadPyodide({
+      stdout: (msg) => send('stdout', msg),
+      stderr: (msg) => send('stderr', msg),
+    });
+  } catch (err) {
+    send('error', 'Failed to initialize Pyodide: ' + String(err));
+    throw err;
+  }
+
+  // Pre-load micropip so users can install packages
+  await pyodide.loadPackage('micropip');
+
+  send('status', 'Python runtime ready');
+  return pyodide;
+}
+
+async function executePython(entryPoint, files) {
+  const py = await ensurePyodide();
+
+  // Mount VFS files into Pyodide's filesystem
+  // Create /output/ directory for visual output
+  try { py.FS.mkdir('/output'); } catch (_e) { /* exists */ }
+
+  for (const [path, content] of Object.entries(files)) {
+    // Skip dotfiles
+    if (path.startsWith('/.')) continue;
+    const dir = path.substring(0, path.lastIndexOf('/')) || '/';
+    // Ensure parent directories exist
+    const parts = dir.split('/').filter(Boolean);
+    let current = '';
+    for (const part of parts) {
+      current += '/' + part;
+      try { py.FS.mkdir(current); } catch (_e) { /* exists */ }
+    }
+    py.FS.writeFile(path, content);
+  }
+
+  // Run the entry point script
+  const code = files[entryPoint];
+  if (!code) {
+    send('error', `Entry point not found: ${entryPoint}`);
+    return { exitCode: 1 };
+  }
+
+  // Set up Python environment so module imports work:
+  const entryDir = entryPoint.substring(0, entryPoint.lastIndexOf('/')) || '/';
+  try {
+    await py.runPythonAsync(`
+import sys, os
+os.chdir(${JSON.stringify(entryDir)})
+_ep_dir = ${JSON.stringify(entryDir)}
+if _ep_dir not in sys.path:
+    sys.path.insert(0, _ep_dir)
+if '/' not in sys.path:
+    sys.path.insert(0, '/')
+__file__ = ${JSON.stringify(entryPoint)}
+del _ep_dir
+`);
+  } catch (_e) { /* best effort */ }
+
+  try {
+    await py.runPythonAsync(code);
+  } catch (err) {
+    send('stderr', String(err));
+    return { exitCode: 1 };
+  }
+
+  // Scan /output/ for new files and send them back
+  try {
+    const outputFiles = py.FS.readdir('/output').filter(f => f !== '.' && f !== '..');
+    for (const filename of outputFiles) {
+      const filePath = '/output/' + filename;
+      try {
+        const data = py.FS.readFile(filePath);
+        const ext = filename.split('.').pop().toLowerCase();
+        if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp'].includes(ext)) {
+          let binary = '';
+          for (let i = 0; i < data.length; i++) {
+            binary += String.fromCharCode(data[i]);
+          }
+          const base64 = btoa(binary);
+          sendFile(filePath, base64);
+        } else {
+          const decoder = new TextDecoder();
+          sendFile(filePath, decoder.decode(data));
+        }
+      } catch (_e) { /* skip unreadable files */ }
+    }
+  } catch (_e) { /* /output/ may not have new files */ }
+
+  return { exitCode: 0 };
+}
+
+// ─── Lua (wasmoon) ──────────────────────────────────────────────────
+
+async function ensureLuaFactory() {
+  if (luaFactory) return luaFactory;
+
+  send('status', 'Loading Lua runtime...');
+
+  try {
+    // Dynamic import of wasmoon from CDN
+    const wasmoon = await import('https://esm.sh/wasmoon@1');
+    luaFactory = new wasmoon.LuaFactory();
+  } catch (err) {
+    send('error', 'Failed to load Lua runtime: ' + String(err));
+    throw err;
+  }
+
+  send('status', 'Lua runtime ready');
+  return luaFactory;
+}
+
+async function executeLua(entryPoint, files) {
+  const factory = await ensureLuaFactory();
+  const engine = await factory.createEngine();
+
+  try {
+    // Override print to capture stdout
+    engine.global.set('print', function (...args) {
+      send('stdout', args.map(String).join('\t'));
+    });
+
+    // Pre-load module files so require() works
+    const moduleFiles = {};
+    for (const [path, content] of Object.entries(files)) {
+      if (path.endsWith('.lua') && path !== entryPoint) {
+        const modName = path
+          .replace(/^\//, '')
+          .replace(/\.lua$/, '')
+          .replace(/\//g, '.');
+        moduleFiles[modName] = content;
+      }
+    }
+
+    // Register custom searcher for VFS modules
+    engine.global.set('__vfs_modules', JSON.stringify(moduleFiles));
+
+    await engine.doString(`
+      local vfs_modules = {}
+      local json_str = __vfs_modules
+      -- Simple JSON parse for module map (keys and string values only)
+      for key, value in json_str:gmatch('"([^"]+)":"(.-[^\\\\])"') do
+        -- Unescape basic sequences
+        value = value:gsub('\\\\n', '\\n'):gsub('\\\\t', '\\t'):gsub('\\\\"', '"'):gsub('\\\\\\\\', '\\\\')
+        vfs_modules[key] = value
+      end
+      __vfs_modules = nil
+
+      table.insert(package.searchers, 2, function(modname)
+        local source = vfs_modules[modname]
+        if source then
+          local fn, err = load(source, "@" .. modname .. ".lua")
+          if fn then return fn
+          else return "\\n\\tload error: " .. err end
+        end
+        return "\\n\\tno VFS module '" .. modname .. "'"
+      end)
+    `);
+
+    // Run the entry point
+    const code = files[entryPoint];
+    if (!code) {
+      send('error', 'Entry point not found: ' + entryPoint);
+      engine.global.close();
+      return { exitCode: 1 };
+    }
+
+    await engine.doString(code);
+
+    engine.global.close();
+    return { exitCode: 0 };
+
+  } catch (err) {
+    send('stderr', String(err));
+    try { engine.global.close(); } catch (_e) { /* best effort */ }
+    return { exitCode: 1 };
+  }
+}
+
+// ─── Message handler ────────────────────────────────────────────────
+
+self.onmessage = async function (event) {
+  const msg = event.data;
+
+  if (msg.type === 'execute') {
+    const { runtime, entryPoint, files } = msg.payload;
+
+    try {
+      let result;
+      if (runtime === 'python') {
+        result = await executePython(entryPoint, files);
+      } else if (runtime === 'lua') {
+        result = await executeLua(entryPoint, files);
+      } else {
+        send('error', 'Unknown runtime: ' + runtime);
+        self.postMessage({ type: 'complete', exitCode: 1 });
+        return;
+      }
+
+      self.postMessage({ type: 'complete', exitCode: result.exitCode });
+    } catch (err) {
+      send('error', String(err));
+      self.postMessage({ type: 'complete', exitCode: 1 });
+    }
+  }
+};

tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules", "desktop"]
+}

vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    exclude: ['e2e/**', '**/node_modules/**', 'desktop/app/**', 'desktop/dist/**'],
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname),
+    },
+  },
+});