@inflector/aura 0.6.7 → 0.7.0

package/dist/bin.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
 export declare function build(silent?: boolean): void;
+export declare function serve(mode: "dev" | "prod"): Promise<void>;
 export declare function dev(): Promise<void>;
 //# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAmLA,wBAAgB,KAAK,CAAC,MAAM,UAAQ,QAgDnC;AA0aD,wBAAsB,GAAG,kBAqExB"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAmLA,wBAAgB,KAAK,CAAC,MAAM,UAAQ,QAgDnC;AAwJD,wBAAsB,KAAK,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,iBAiJ/C;AAmRD,wBAAsB,GAAG,kBAiFxB"}

package/dist/bin.js

@@ -321,6 +321,150 @@ async function pull() {
         log.error(err.message);
     }
 }
+export async function serve(mode) {
+    let Config;
+    try {
+        Config = JSON.parse(fs.readFileSync("./Aura/config.json", "utf-8"));
+    }
+    catch {
+        log.error("Config file not found. Run `aura init` first.");
+        return;
+    }
+    const upstreamUrl = Config.Url.replace(/\/$/, "");
+    const AURA_KEY = process.env.AURA_KEY;
+    const proxyRequest = async (req) => {
+        const url = new URL(req.url);
+        const targetUrl = `${upstreamUrl}${url.pathname}${url.search}`;
+        const headers = new Headers();
+        // @ts-ignore
+        for (const [key, value] of req.headers.entries()) {
+            if (["host", "accept-encoding", "connection", "transfer-encoding"].includes(key.toLowerCase()))
+                continue;
+            headers.set(key, value);
+        }
+        headers.set("x-forwarded-host", req.headers.get("host") ?? "");
+        headers.set("x-forwarded-proto", req.headers.get("x-forwarded-proto") ?? "http");
+        headers.set("x-forwarded-for", req.headers.get("x-forwarded-for") ?? "");
+        if (AURA_KEY)
+            headers.set("Authorization", `Bearer ${AURA_KEY}`);
+        try {
+            const upstream = await fetch(targetUrl, {
+                method: req.method,
+                headers,
+                body: req.method === "GET" || req.method === "HEAD" ? undefined : req.body,
+                signal: req.signal,
+            });
+            const resHeaders = new Headers();
+            // @ts-ignore
+            for (const [key, value] of upstream.headers.entries()) {
+                if (["content-encoding", "content-length", "transfer-encoding"].includes(key.toLowerCase()))
+                    continue;
+                resHeaders.append(key, value);
+            }
+            return new Response(upstream.body, {
+                status: upstream.status,
+                statusText: upstream.statusText,
+                headers: resHeaders,
+            });
+        }
+        catch (err) {
+            if (err.name === "AbortError" || req.signal?.aborted) {
+                return new Response(null, { status: 499 });
+            }
+            return new Response(JSON.stringify({ error: "Upstream Proxy Failed" }), {
+                status: 502,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    };
+    if (mode === "dev") {
+        const { createServer, mergeConfig, loadConfigFromFile } = await import("vite");
+        const configFile = path.resolve(process.cwd(), "vite.config.ts");
+        const configResult = await loadConfigFromFile({ command: "serve", mode: "development" }, configFile);
+        if (!configResult?.config) {
+            log.error("Could not load vite.config.ts");
+            return;
+        }
+        const vite = await createServer(mergeConfig(configResult.config, {
+            configFile: false,
+            server: {
+                proxy: {
+                    "/api": {
+                        target: upstreamUrl,
+                        changeOrigin: false, // don't rewrite origin — breaks cookies
+                        secure: false,
+                        configure(proxy) {
+                            proxy.on("proxyReq", (proxyReq, req) => {
+                                proxyReq.setHeader("connection", "close");
+                                if (AURA_KEY)
+                                    proxyReq.setHeader("Authorization", `Bearer ${AURA_KEY}`);
+                                // preserve cookies
+                                if (req.headers.cookie)
+                                    proxyReq.setHeader("cookie", req.headers.cookie);
+                            });
+                            proxy.on("proxyRes", (proxyRes) => {
+                                // ensure set-cookie is not stripped
+                                if (proxyRes.headers["set-cookie"]) {
+                                    proxyRes.headers["set-cookie"] = proxyRes.headers["set-cookie"]
+                                        .map((c) => c.replace(/; secure/gi, "").replace(/; samesite=none/gi, ""));
+                                }
+                            });
+                        },
+                    },
+                },
+            },
+        }));
+        if (vite.bindCLIShortcuts)
+            vite.bindCLIShortcuts({ print: true });
+        await vite.listen();
+        vite.printUrls();
+        return;
+    }
+    // prod
+    const configFile = path.resolve(process.cwd(), "vite.config.ts");
+    const configResult = await loadConfigFromFile({ command: "serve", mode: "development" }, configFile);
+    const port = configResult?.config?.preview?.port ?? 80;
+    const getMimeType = (p) => {
+        if (p.endsWith(".js"))
+            return "application/javascript";
+        if (p.endsWith(".css"))
+            return "text/css";
+        if (p.endsWith(".html"))
+            return "text/html";
+        if (p.endsWith(".json"))
+            return "application/json";
+        if (p.endsWith(".png"))
+            return "image/png";
+        if (p.endsWith(".jpg") || p.endsWith(".jpeg"))
+            return "image/jpeg";
+        if (p.endsWith(".svg"))
+            return "image/svg+xml";
+        return "application/octet-stream";
+    };
+    Bun.serve({
+        hostname: "0.0.0.0",
+        port,
+        idleTimeout: 0,
+        async fetch(req) {
+            const url = new URL(req.url);
+            if (url.pathname.startsWith("/api"))
+                return proxyRequest(req);
+            const filePath = `./dist${url.pathname}`;
+            const file = Bun.file(filePath);
+            if (await file.exists()) {
+                return new Response(file, { headers: { "Content-Type": getMimeType(filePath) } });
+            }
+            const index = Bun.file("./dist/index.html");
+            if (await index.exists()) {
+                return new Response(index, { headers: { "Content-Type": "text/html" } });
+            }
+            return new Response("Not Found", { status: 404 });
+        },
+    });
+    log.success(`Server running on http://localhost:${port}`);
+    log.dim(`   • Proxying /api → ${upstreamUrl}`);
+    log.dim(`   • Serving static → ./dist`);
+}
 function init(c = "vite") {
     log.info("Initializing Aura project...");
     const filesContent = {
@@ -582,11 +726,17 @@ export async function dev() {
                     changeOrigin: true,
                     secure: false,
                     configure(proxy, _options) {
-                        proxy.on("proxyReq", (proxyReq) => {
+                        proxy.on("proxyReq", (proxyReq, req, res) => {
                             proxyReq.setHeader("Connection", "close");
                             if (AURA_KEY) {
                                 proxyReq.setHeader("Authorization", `Bearer ${AURA_KEY}`);
                             }
+                            // Abort upstream request if client disconnects
+                            req.on("close", () => {
+                                if (!res.writableEnded) {
+                                    proxyReq.destroy();
+                                }
+                            });
                         });
                     },
                 },
@@ -643,6 +793,7 @@ async function start() {
                         body: req.method === "GET" || req.method === "HEAD"
                             ? undefined
                             : req.body,
+                        signal: req.signal,
                     });
                     const proxyHeaders = new Headers(proxiedResp.headers);
                     proxyHeaders.delete("content-encoding");
@@ -653,7 +804,11 @@ async function start() {
                         headers: proxyHeaders,
                     });
                 }
-                catch {
+                catch (err) {
+                    // Client disconnected — no point sending a response
+                    if (err.name === "AbortError" || req.signal.aborted) {
+                        return new Response(null, { status: 499 });
+                    }
                     return new Response(JSON.stringify({ error: "Upstream Proxy Failed" }), { status: 502, headers: { "Content-Type": "application/json" } });
                 }
             }
@@ -721,9 +876,9 @@ async function main() {
                 await login();
                 break;
             case "dev":
-                return await dev();
+                return await serve("dev");
             case "start":
-                return await start();
+                return await serve("prod");
             case undefined:
                 log.info("Available commands: init, pull, push, build, login, ping");
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inflector/aura",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",