create-jen-app 0.1.0

package/templates/static/lib/server/app.js

@@ -0,0 +1,381 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { existsSync, watch } from "node:fs";
+import { join, extname } from "node:path";
+import sirv from "sirv";
+import { createScssCompiler } from "../css/compiler.js";
+import { scanRoutes } from "../core/routes/scan.js";
+import { matchRoute } from "../core/routes/match.js";
+import { log } from "../shared/log.js";
+import { Kernel } from "../middleware/kernel.js";
+import { renderRouteToHtml } from "../runtime/render.js";
+import { HMR_CLIENT_SCRIPT } from "../runtime/hmr.js";
+import { headersToObject, parseCookies } from "../core/http.js";
+import { tryHandleApiRoute } from "./api-routes.js";
+import { resolve } from "node:path";
+import { buildHydrationModule, runtimeHydrateModule, invalidateCache, } from "./runtimeServe.js";
+import { invalidateVueCache, invalidateSvelteCache, } from "../compilers/esbuild-plugins.js";
+export async function createApp(opts) {
+    const { config, mode } = opts;
+    // HMR / Live Reload Setup
+    const hmrClients = new Set();
+    if (mode === "dev") {
+        const sitePath = join(process.cwd(), config.siteDir);
+        log.info(`[HMR] Watching ${sitePath} for changes...`);
+        // Recursive watch (Node 20+)
+        let debounceTimer;
+        try {
+            watch(sitePath, { recursive: true }, (eventType, filename) => {
+                if (!filename)
+                    return;
+                // Ignore common temporary/hidden files to prevent infinite loops
+                if (filename.startsWith(".") ||
+                    filename.includes("node_modules") ||
+                    filename.endsWith("~") ||
+                    filename.endsWith(".tmp") ||
+                    filename.endsWith(".esbuild.mjs") || // Ignore build artifacts
+                    filename.includes("\\.") || // Windows hidden files
+                    filename.includes("/.") // Unix hidden files
+                ) {
+                    return;
+                }
+                // Debounce to avoid double events
+                clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => {
+                    const ext = extname(filename);
+                    // Normalize path
+                    const fullPath = join(sitePath, filename);
+                    log.info(`[HMR] Change detected: ${filename}`);
+                    if (ext === ".css" || ext === ".scss") {
+                        // Hot CSS
+                        const cssName = filename.replace(/\.scss$/, ".css");
+                        for (const client of hmrClients) {
+                            client.write(`event: style-update\ndata: ${JSON.stringify({ file: cssName })}\n\n`);
+                        }
+                    }
+                    else {
+                        // Invalidate caches for changed file
+                        invalidateCache(fullPath);
+                        if (ext === ".vue")
+                            invalidateVueCache(fullPath);
+                        if (ext === ".svelte")
+                            invalidateSvelteCache(fullPath);
+                        // Full reload for JS/TS/Vue/Svelte/Other
+                        for (const client of hmrClients) {
+                            client.write(`event: reload\ndata: {}\n\n`);
+                        }
+                    }
+                }, 100);
+            });
+        }
+        catch (err) {
+            log.warn(`[HMR] Watch failed: ${err}`);
+        }
+    }
+    const routes = scanRoutes(config);
+    log.info(`Routes discovered: ${routes.length}`);
+    for (const r of routes)
+        log.info(`  ${r.urlPath} -> ${r.filePath}`);
+    const serveAssets = sirv(join(process.cwd(), config.siteDir), {
+        dev: mode === "dev",
+        etag: true,
+    });
+    const serveDist = sirv(join(process.cwd(), config.distDir), {
+        dev: mode === "dev",
+        etag: true,
+    });
+    const middlewares = [
+        async (ctx, next) => {
+            log.info(`${ctx.req.method} ${ctx.url.pathname}`);
+            await next();
+        },
+        async (ctx, next) => {
+            // runtime internal modules
+            if (ctx.url.pathname === "/__runtime/hydrate.js") {
+                ctx.res.statusCode = 200;
+                ctx.res.setHeader("content-type", "application/javascript; charset=utf-8");
+                ctx.res.end(runtimeHydrateModule());
+                return;
+            }
+            if (ctx.url.pathname === "/__runtime/island-hydration-client.js") {
+                ctx.res.statusCode = 200;
+                ctx.res.setHeader("content-type", "application/javascript; charset=utf-8");
+                const islandCode = `
+import { hydrate } from "https://esm.sh/preact@10";
+import { h } from "https://esm.sh/preact@10";
+
+function extractIslands() {
+  const islands = [];
+  const html = document.documentElement.outerHTML;
+  const regex = /<!--__ISLAND_(LOAD|IDLE|VISIBLE)__:([^:]+):([^:]+):(.+?)-->/g;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    const strategy = match[1].toLowerCase();
+    const id = match[2];
+    const component = match[3];
+    const propsStr = match[4].replace(/\\\\u003c/g, "<");
+    try {
+      islands.push({
+        id, component, strategy,
+        props: JSON.parse(propsStr),
+      });
+    } catch (e) {
+      console.warn('Failed to parse island ' + id);
+    }
+  }
+  return islands;
+}
+
+async function hydrateIsland(island) {
+  const target = document.getElementById(island.id);
+  if (!target) {
+    console.warn('Island target #' + island.id + ' not found');
+    return;
+  }
+  try {
+    const hydrationUrl = '/__hydrate?file=' + encodeURIComponent(island.component);
+    const mod = await import(hydrationUrl);
+    const Component = mod.default;
+    if (!Component) {
+      console.warn('Component not exported from ' + island.component);
+      return;
+    }
+    const app = h(Component, island.props);
+    hydrate(app, target);
+  } catch (err) {
+    console.error('Failed to hydrate island ' + island.id + ':', err);
+  }
+}
+
+function hydrateWithStrategy(islands) {
+  for (const island of islands) {
+    switch (island.strategy) {
+      case 'load':
+        hydrateIsland(island);
+        break;
+      case 'idle':
+        if ('requestIdleCallback' in window) {
+          requestIdleCallback(() => hydrateIsland(island));
+        } else {
+          setTimeout(() => hydrateIsland(island), 2000);
+        }
+        break;
+      case 'visible':
+        if ('IntersectionObserver' in window) {
+          const target = document.getElementById(island.id);
+          if (target) {
+            const observer = new IntersectionObserver((entries) => {
+              if (entries[0].isIntersecting) {
+                hydrateIsland(island);
+                observer.disconnect();
+              }
+            }, { threshold: 0.1 });
+            observer.observe(target);
+          }
+        } else {
+          setTimeout(() => hydrateIsland(island), 3000);
+        }
+        break;
+    }
+  }
+}
+
+export function initializeIslands() {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', () => {
+      const islands = extractIslands();
+      hydrateWithStrategy(islands);
+    });
+  } else {
+    const islands = extractIslands();
+    hydrateWithStrategy(islands);
+  }
+}
+
+initializeIslands();
+`;
+                ctx.res.end(islandCode);
+                return;
+            }
+            // HMR Endpoint (SSE)
+            if (ctx.url.pathname === "/__hmr" && mode === "dev") {
+                ctx.res.statusCode = 200;
+                ctx.res.setHeader("content-type", "text/event-stream");
+                ctx.res.setHeader("cache-control", "no-cache");
+                ctx.res.setHeader("connection", "keep-alive");
+                ctx.res.write("data: connected\n\n");
+                hmrClients.add(ctx.res);
+                ctx.req.on("close", () => {
+                    hmrClients.delete(ctx.res);
+                });
+                return;
+            }
+            if (ctx.url.pathname === "/__hydrate") {
+                const file = ctx.url.searchParams.get("file");
+                if (!file) {
+                    ctx.res.statusCode = 400;
+                    ctx.res.end("missing file");
+                    return;
+                }
+                const js = buildHydrationModule(file);
+                ctx.res.statusCode = 200;
+                ctx.res.setHeader("content-type", "application/javascript; charset=utf-8");
+                ctx.res.setHeader("cache-control", "no-store");
+                ctx.res.end(js);
+                return;
+            }
+            await next();
+        },
+        async (ctx, next) => {
+            // API routes
+            const handled = await tryHandleApiRoute({
+                req: ctx.req,
+                res: ctx.res,
+                siteDir: config.siteDir,
+            });
+            if (handled)
+                return;
+            await next();
+        },
+        async (ctx, next) => {
+            // dist
+            if (mode === "prod") {
+                await new Promise((resolve) => {
+                    serveDist(ctx.req, ctx.res, () => resolve());
+                });
+                if (ctx.res.writableEnded || ctx.res.headersSent)
+                    return;
+            }
+            await next();
+        },
+        async (ctx, next) => {
+            // SCSS Compilation (Dev)
+            if (mode === "dev" && ctx.url.pathname.endsWith(".css")) {
+                let scssFile = null;
+                const basePath = resolve(process.cwd());
+                if (ctx.url.pathname === "/styles.css") {
+                    // Global SCSS
+                    if (config.css?.globalScss) {
+                        // Already includes siteDir if needed, but add it if it doesn't
+                        const scssPath = config.css.globalScss.startsWith(config.siteDir)
+                            ? config.css.globalScss
+                            : join(config.siteDir, config.css.globalScss);
+                        scssFile = join(basePath, scssPath);
+                        console.log('[DEBUG CSS] Looking for global SCSS:', scssFile, 'exists:', existsSync(scssFile));
+                    }
+                    else {
+                        console.log('[DEBUG CSS] No config.css.globalScss found');
+                    }
+                }
+                else {
+                    // Map /foo.css -> siteDir/foo.scss
+                    const rel = ctx.url.pathname.slice(1);
+                    const tryPath = join(basePath, config.siteDir, rel.replace(/\.css$/, ".scss"));
+                    if (existsSync(tryPath)) {
+                        scssFile = tryPath;
+                    }
+                }
+                if (scssFile && existsSync(scssFile)) {
+                    const compiler = createScssCompiler();
+                    const result = compiler.compile({
+                        inputPath: scssFile,
+                        minified: false,
+                        sourceMap: true,
+                    });
+                    if (result.error) {
+                        ctx.res.statusCode = 500;
+                        ctx.res.setHeader("content-type", "text/css");
+                        ctx.res.end(`/* SCSS Error: ${result.error.replace(/\*\//g, "* /")} */ body::before { position:fixed; top:0; left:0; width:100%; content: "SCSS Error: ${result.error
+                            .replace(/\\/g, "\\\\")
+                            .replace(/"/g, '\\"')}"; display: block; background: red; color: white; padding: 1em; z-index:9999; white-space: pre-wrap; }`);
+                        return;
+                    }
+                    ctx.res.statusCode = 200;
+                    ctx.res.setHeader("content-type", "text/css");
+                    ctx.res.end(result.css);
+                    return;
+                }
+            }
+            await next();
+        },
+        async (ctx, next) => {
+            // site assets in dev
+            if (mode === "dev") {
+                await new Promise((resolve) => {
+                    serveAssets(ctx.req, ctx.res, () => resolve());
+                });
+                if (ctx.res.writableEnded || ctx.res.headersSent)
+                    return;
+            }
+            await next();
+        },
+        async (ctx, next) => {
+            // SSR
+            if (ctx.req.method !== "GET")
+                return next();
+            const m = matchRoute(routes, ctx.url.pathname);
+            if (!m)
+                return next();
+            const reqHeaders = headersToObject(ctx.req.headers);
+            const cookies = parseCookies(ctx.req);
+            const query = {};
+            for (const [k, v] of ctx.url.searchParams.entries())
+                query[k] = v;
+            try {
+                const html = await renderRouteToHtml({
+                    config,
+                    route: m.route,
+                    req: ctx.req,
+                    res: ctx.res,
+                    url: ctx.url,
+                    params: m.params,
+                    query,
+                    headers: reqHeaders,
+                    cookies,
+                });
+                let finalHtml = html;
+                if (mode === "dev") {
+                    // Inject HMR client
+                    finalHtml = html.replace("</body>", `<script>${HMR_CLIENT_SCRIPT}</script></body>`);
+                }
+                ctx.res.statusCode = 200;
+                ctx.res.setHeader("content-type", "text/html; charset=utf-8");
+                ctx.res.end(finalHtml);
+            }
+            catch (err) {
+                // Middleware may have sent a response (redirect/json)
+                if (err.message === "__REDIRECT__" || err.message === "__JSON__") {
+                    return; // Response already sent
+                }
+                throw err;
+            }
+        },
+        async (ctx) => {
+            ctx.res.statusCode = 404;
+            ctx.res.setHeader("content-type", "text/plain; charset=utf-8");
+            ctx.res.end("404 Not Found");
+        },
+    ];
+    const kernel = new Kernel();
+    middlewares.forEach((m) => kernel.use(m));
+    return {
+        async handle(req, res) {
+            await kernel.handle(req, res);
+        },
+    };
+}

package/templates/static/lib/server/runtimeServe.d.ts

@@ -0,0 +1,4 @@
+export declare function runtimeHydrateModule(): string;
+export declare function invalidateCache(filePath: string): void;
+export declare function buildHydrationModule(routeIdOrPath: string): string;
+export declare function getHydrationEtag(filePath: string): string | null;

package/templates/static/lib/server/runtimeServe.js

@@ -0,0 +1,125 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { buildSync } from "esbuild";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { basename, dirname } from "node:path";
+const cache = new Map();
+function etagOf(s) {
+    return createHash("sha1").update(s).digest("hex");
+}
+export function runtimeHydrateModule() {
+    // Browser-safe runtime (ESM) using CDN preact (fast + zero bundler)
+    return `
+import { hydrate } from "https://esm.sh/preact@10.25.4";
+import { h } from "https://esm.sh/preact@10.25.4";
+
+function getFrameworkData() {
+  const el = document.getElementById("__FRAMEWORK_DATA__");
+  if (!el) return null;
+  try { return JSON.parse(el.textContent || "null"); } catch { return null; }
+}
+
+export async function hydrateClient(entryPath) {
+  const data = getFrameworkData();
+  const mod = await import(entryPath);
+  const Page = mod.default;
+  const app = h(Page, {
+    data: data?.data ?? null,
+    params: data?.params ?? {},
+    query: data?.query ?? {}
+  });
+  const root = document.getElementById("app");
+  if (!root) return;
+  hydrate(app, root);
+}
+`;
+}
+export function invalidateCache(filePath) {
+    cache.delete(filePath);
+}
+export function buildHydrationModule(routeIdOrPath) {
+    // routeIdOrPath is now a route ID like "route_index" or "route_blog_slug"
+    // or a fallback filePath for backwards compatibility
+    let filePath = routeIdOrPath;
+    // For now, keep simple direct file path support
+    // In production, we'd resolve routeId -> filePath via config
+    if (!existsSync(filePath)) {
+        return `export default function Page(){ return null }`;
+    }
+    const key = filePath;
+    // Simple dev cache: check if file content changed?
+    // Actually, for dev speed, we trust explicit invalidation or just rebuild on request.
+    // Since buildSync is fast for single files, let's just rebuild if not in cache.
+    // The cache is populated. If invalidation happens, it's removed.
+    if (cache.has(key)) {
+        return cache.get(key).js;
+    }
+    // Use a proxy entry to allow tree-shaking of server-only exports (like loader)
+    const fileName = basename(filePath);
+    const dir = dirname(filePath);
+    const proxyContent = `export { default } from "./${fileName}";`;
+    try {
+        const jsOutput = buildSync({
+            stdin: {
+                contents: proxyContent,
+                resolveDir: dir,
+                sourcefile: "hydration-proxy.tsx",
+                loader: "tsx",
+            },
+            format: "esm",
+            platform: "browser",
+            bundle: true,
+            write: false,
+            sourcemap: "inline",
+            jsx: "automatic",
+            jsxImportSource: "preact",
+            define: {
+                "process.env.NODE_ENV": JSON.stringify("development"),
+            },
+            external: [
+                "preact",
+                "preact/hooks",
+                "preact/jsx-runtime",
+                "preact-render-to-string",
+            ],
+            // Plugins not supported in buildSync, only in build()
+            // plugins: [vueEsbuildPlugin(), svelteEsbuildPlugin()],
+        }).outputFiles?.[0]?.text;
+        if (!jsOutput) {
+            console.error("[HYDRATION] Failed to build module for:", filePath);
+            return `export default function Page(){ return null }`;
+        }
+        const out = `
+import { h } from "https://esm.sh/preact@10.25.4";
+import { Fragment } from "https://esm.sh/preact@10.25.4";
+import { jsx, jsxs } from "https://esm.sh/preact@10.25.4/jsx-runtime";
+` + jsOutput;
+        const etag = etagOf(out);
+        cache.set(key, { js: out, etag });
+        return out;
+    }
+    catch (err) {
+        console.error("[HYDRATION] Build error for", filePath, ":", err);
+        return `export default function Page(){ return null }`;
+    }
+}
+export function getHydrationEtag(filePath) {
+    const v = cache.get(filePath);
+    return v?.etag ?? null;
+}

package/templates/static/lib/shared/log.d.ts

@@ -0,0 +1,5 @@
+export declare const log: {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+};

package/templates/static/lib/shared/log.js

@@ -0,0 +1,31 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+function ts() {
+    return new Date().toISOString();
+}
+export const log = {
+    info(msg) {
+        console.log(`[${ts()}] [INFO] ${msg}`);
+    },
+    warn(msg) {
+        console.warn(`[${ts()}] [WARN] ${msg}`);
+    },
+    error(msg) {
+        console.error(`[${ts()}] [ERROR] ${msg}`);
+    },
+};

package/templates/static/node_modules/.bin/esbuild

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../esbuild/bin/esbuild" "$@"
+else 
+  exec node  "$basedir/../esbuild/bin/esbuild" "$@"
+fi

package/templates/static/node_modules/.bin/esbuild.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\esbuild\bin\esbuild" %*

package/templates/static/node_modules/.bin/esbuild.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../esbuild/bin/esbuild" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../esbuild/bin/esbuild" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../esbuild/bin/esbuild" $args
+  } else {
+    & "node$exe"  "$basedir/../esbuild/bin/esbuild" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

package/templates/static/node_modules/.bin/tsc

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../typescript/bin/tsc" "$@"
+else 
+  exec node  "$basedir/../typescript/bin/tsc" "$@"
+fi

package/templates/static/node_modules/.bin/tsc.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\typescript\bin\tsc" %*

package/templates/static/node_modules/.bin/tsc.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../typescript/bin/tsc" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../typescript/bin/tsc" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../typescript/bin/tsc" $args
+  } else {
+    & "node$exe"  "$basedir/../typescript/bin/tsc" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret