flashts 1.0.0

package/server/index.ts

@@ -0,0 +1,213 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { join } from "path";
+import { mkdir, readdir, readFile } from "fs/promises";
+import { serveStatic } from "hono/bun";
+
+const app = new Hono();
+
+// Enable CORS for the frontend
+app.use("/*", cors());
+
+// Ensure tmp directory exists
+const TMP_DIR = join(process.cwd(), "tmp");
+await mkdir(TMP_DIR, { recursive: true });
+
+// Serve static files from the client/dist directory
+app.use("/*", serveStatic({ root: "./client/dist" }));
+
+app.get("/api/health", (c) => c.text("FlashTS API Active"));
+
+app.post("/execute", async (c) => {
+  try {
+    const body = await c.req.json();
+    const { files, entryPoint } = body;
+
+    if (!files || !entryPoint) {
+      return c.json({ error: "Invalid project state" }, 400);
+    }
+
+    const sessionId = crypto.randomUUID();
+    const sessionDir = join(TMP_DIR, sessionId);
+    await mkdir(sessionDir, { recursive: true });
+
+    for (const [name, content] of Object.entries(files)) {
+        const filePath = join(sessionDir, name as string);
+        const dir = join(sessionDir, join(...(name as string).split('/').slice(0, -1)));
+        if (dir !== sessionDir) await mkdir(dir, { recursive: true });
+        await Bun.write(filePath, content as string);
+    }
+
+    const proc = Bun.spawn(["bun", "run", entryPoint], {
+        stdout: "pipe",
+        stderr: "pipe",
+        cwd: sessionDir,
+    });
+
+    const timeout = 10000;
+    const timeoutPromise = new Promise((_, reject) => 
+        setTimeout(() => {
+            proc.kill();
+            reject(new Error("Execution timed out"));
+        }, timeout)
+    );
+
+    const executionPromise = (async () => {
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+        return { stdout, stderr, exitCode };
+    })();
+
+    const result = { ...await Promise.race([executionPromise, timeoutPromise]) as any, sessionId };
+
+    setTimeout(() => {
+        try {
+            import("fs").then(fs => fs.promises.rm(sessionDir, { recursive: true, force: true }));
+        } catch (e) {}
+    }, 5000);
+
+    return c.json(result);
+
+  } catch (error: any) {
+    return c.json({ 
+        stdout: "", 
+        stderr: error.message || String(error), 
+        exitCode: 1 
+    }, 500); 
+  }
+});
+
+app.post("/install", async (c) => {
+    const { package: pkgName } = await c.req.json();
+    if (!pkgName || typeof pkgName !== 'string') {
+        return c.json({ error: "Invalid package name" }, 400);
+    }
+
+    try {
+        const proc = Bun.spawn(["bun", "add", pkgName], {
+            cwd: process.cwd(),
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+
+        const output = await new Response(proc.stdout).text();
+        const error = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+
+        if (exitCode !== 0) {
+             return c.json({ success: false, output: error || output }, 500);
+        }
+        
+        return c.json({ success: true, output });
+    } catch (err: any) {
+        return c.json({ success: false, output: err.message }, 500);
+    }
+});
+
+app.get("/dependencies", async (c) => {
+    try {
+        const pkgPath = join(process.cwd(), "package.json");
+        const pkgData = JSON.parse(await readFile(pkgPath, "utf-8"));
+        return c.json(pkgData.dependencies || {});
+    } catch (e) {
+        return c.json({});
+    }
+});
+
+app.post("/uninstall", async (c) => {
+    const { package: pkgName } = await c.req.json();
+    if (!pkgName || typeof pkgName !== 'string') {
+        return c.json({ error: "Invalid package name" }, 400);
+    }
+
+    try {
+        const proc = Bun.spawn(["bun", "remove", pkgName], {
+            cwd: process.cwd(),
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+
+        const output = await new Response(proc.stdout).text();
+        const error = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+
+        if (exitCode !== 0) {
+             return c.json({ success: false, output: error || output }, 500);
+        }
+        
+        return c.json({ success: true, output });
+    } catch (err: any) {
+        return c.json({ success: false, output: err.message }, 500);
+    }
+});
+
+async function getPackageTypeTree(pkgName: string) {
+    const pkgDir = join(process.cwd(), "node_modules", pkgName);
+    const files: Record<string, string> = {};
+
+    async function scan(dir: string, relativePath: string = "") {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const res = join(dir, entry.name);
+            const rel = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+            
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules') continue;
+                await scan(res, rel);
+            } else if (entry.name.endsWith(".d.ts") || entry.name === "package.json") {
+                try {
+                    files[rel] = await readFile(res, "utf-8");
+                } catch (e) {
+                }
+            }
+        }
+    }
+
+    try {
+        await scan(pkgDir);
+        return files;
+    } catch (e) {
+        try {
+            const typesPkgName = pkgName.startsWith('@') 
+                ? pkgName.slice(1).replace('/', '__') 
+                : pkgName;
+            const atTypesDir = join(process.cwd(), "node_modules", "@types", typesPkgName);
+            await scan(atTypesDir);
+            return files;
+        } catch (e2) {
+            return null;
+        }
+    }
+}
+
+app.get("/package-types/:pkg{.+$}", async (c) => {
+    const pkgName = c.req.param("pkg");
+    const tree = await getPackageTypeTree(pkgName);
+    
+    if (!tree) {
+        return c.json({ error: "Types not found" }, 404);
+    }
+
+    return c.json({ tree, pkgName });
+});
+
+app.get("/search", async (c) => {
+    const query = c.req.query("q");
+    if (!query) return c.json({ objects: [] });
+
+    try {
+        const res = await fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=20`);
+        const data = await res.json();
+        return c.json(data);
+    } catch (err) {
+        return c.json({ objects: [] });
+    }
+});
+
+const port = parseInt(process.env.PORT || "3000");
+
+export default {
+    port,
+    fetch: app.fetch,
+};

package/server/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "server",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@types/react": "^19.2.9",
+    "hono": "^4.11.5",
+    "react": "^19.2.3"
+  }
+}

package/server/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/tmp/e656e349-2c39-4bc3-b334-6b5eb957e306/main.ts

@@ -0,0 +1,2 @@
+// Welcome to FlashTS!
+console.log("Hello from main.tssa");