@ezetgalaxy/titan 25.12.8 → 25.13.0

package/index.js

@@ -4,11 +4,11 @@ import path from "path";
 import { execSync, spawn } from "child_process";
 import { fileURLToPath } from "url";
 
-// __dirname in ES modules
+/* Resolve __dirname for ES modules */
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Colors
+/* Colors */
 const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
 const green = (t) => `\x1b[32m${t}\x1b[0m`;
 const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
@@ -18,7 +18,13 @@ const bold = (t) => `\x1b[1m${t}\x1b[0m`;
 const args = process.argv.slice(2);
 const cmd = args[0];
 
-// COPY TEMPLATES
+/* Titan version (read from package.json) */
+const pkg = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
+);
+const TITAN_VERSION = pkg.version;
+
+/* Safe copy directory */
 function copyDir(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
 
@@ -34,20 +40,21 @@ function copyDir(src, dest) {
     }
 }
 
-// HELP
+/* HELP */
 function help() {
     console.log(`
-${bold(cyan("Titan CLI"))}
+${bold(cyan("Titan CLI"))}  v${TITAN_VERSION}
 
 ${green("tit init <project>")}   Create new Titan project
 ${green("tit dev")}              Dev mode (hot reload)
 ${green("tit build")}            Build production Rust server
 ${green("tit start")}            Start production binary
-${green("tit update")}           Update to latest version
+${green("tit update")}           Update Titan engine
+${green("tit --version")}        Show Titan CLI version
 `);
 }
 
-// INIT PROJECT
+/* INIT PROJECT */
 function initProject(name) {
     if (!name) return console.log(red("Usage: tit init <project>"));
 
@@ -61,7 +68,6 @@ function initProject(name) {
 
     console.log(cyan(`Creating Titan project → ${target}`));
 
-    copyDir(templateDir, target);
     copyDir(templateDir, target);
 
     [".gitignore", ".dockerignore", "Dockerfile"].forEach((file) => {
@@ -70,13 +76,12 @@ function initProject(name) {
         if (fs.existsSync(src)) fs.copyFileSync(src, dest);
     });
 
-
     console.log(green("✔ Titan project created!"));
     console.log(cyan("Installing dependencies..."));
 
     execSync(`npm install esbuild --silent`, {
         cwd: target,
-        stdio: "inherit"
+        stdio: "inherit",
     });
 
     console.log(green("✔ Dependencies installed"));
@@ -87,31 +92,44 @@ Next steps:
 `);
 }
 
-// BUNDLE
-function runBundler() {
-    const bundler = path.join(process.cwd(), "titan", "bundle.js");
+/* BUNDLER (absolute path, Railway-safe) */
+function runBundler(root) {
+    const bundler = path.join(root, "titan", "bundle.js");
 
-    if (fs.existsSync(bundler)) {
-        execSync(`node ${bundler}`, { stdio: "inherit" });
-    } else {
-        console.log(yellow("Warning: titan/bundle.js missing."));
+    if (!fs.existsSync(bundler)) {
+        console.log(red("ERROR: titan/bundle.js missing."));
+        process.exit(1);
     }
-}
 
-// ------------------------------------------
-// FULL HOT RELOAD DEV SERVER
-// ------------------------------------------
+    execSync(`node "${bundler}"`, { stdio: "inherit" });
+}
 
+/* DEV SERVER — HOT RELOAD */
 async function devServer() {
+    const root = process.cwd();
     console.log(cyan("Titan Dev Mode — Hot Reload Enabled"));
 
     let rustProcess = null;
 
+    function launchRust(done) {
+        const processHandle = spawn("cargo", ["run"], {
+            cwd: path.join(root, "server"),
+            stdio: "inherit",
+            shell: true,
+        });
+
+        processHandle.on("spawn", () => setTimeout(done, 200));
+        processHandle.on("close", (code) =>
+            console.log(`[Titan] Rust server exited: ${code}`)
+        );
+
+        return processHandle;
+    }
+
     function startRust() {
         return new Promise((resolve) => {
-            // if server already running → kill it
             if (rustProcess) {
-                console.log("[Titan] Killing old Rust server...");
+                console.log("[Titan] Restarting Rust server...");
 
                 if (process.platform === "win32") {
                     const killer = spawn("taskkill", ["/PID", rustProcess.pid, "/T", "/F"], {
@@ -134,40 +152,19 @@ async function devServer() {
         });
     }
 
-    function launchRust(done) {
-        const processHandle = spawn("cargo", ["run"], {
-            cwd: path.join(process.cwd(), "server"),
+    /* Build logic */
+    function rebuild() {
+        execSync(`node "${path.join(root, "app", "app.js")}"`, {
             stdio: "inherit",
-            shell: true,
-        });
-
-        processHandle.on("spawn", () => {
-            setTimeout(done, 200); // wait for OS to release port
         });
 
-        processHandle.on("close", (code) => {
-            console.log(`[Titan] Rust server exited: ${code}`);
-        });
-
-        return processHandle;
-    }
-
-
-    function rebuild() {
-        console.log(cyan("Titan: Regenerating routes..."));
-        execSync("node app/app.js", { stdio: "inherit" });
-
-        console.log(cyan("Titan: Bundling actions..."));
-        runBundler();
+        runBundler(root);
     }
 
-    // First build
     rebuild();
     startRust();
 
-    // WATCHER
     const chokidar = (await import("chokidar")).default;
-
     const watcher = chokidar.watch("app", { ignoreInitial: true });
 
     let timer = null;
@@ -176,178 +173,88 @@ async function devServer() {
         if (timer) clearTimeout(timer);
 
         timer = setTimeout(() => {
-            console.log(yellow(`Change detected → ${file}`));
-
+            console.log(yellow(`Change → ${file}`));
             rebuild();
             startRust();
-
         }, 250);
     });
 }
 
-
-// BUILD RELEASE — PRODUCTION READY
+/* PRODUCTION BUILD */
 function buildProd() {
-    console.log(cyan("Titan: Building production output..."));
+    const root = process.cwd();
+    const appJs = path.join(root, "app", "app.js");
 
-    const projectRoot = process.cwd();
-
-    const appJs = path.join(projectRoot, "app", "app.js");
-    const bundler = path.join(projectRoot, "titan", "bundle.js");
-    const serverDir = path.join(projectRoot, "server");
+    console.log(cyan("Titan: Building production output..."));
 
-    // 1) Ensure app/app.js exists
     if (!fs.existsSync(appJs)) {
-        console.log(red("ERROR: app/app.js not found. Cannot build Titan project."));
+        console.log(red("ERROR: app/app.js missing."));
         process.exit(1);
     }
 
-    // 2) Ensure bundler exists
-    if (!fs.existsSync(bundler)) {
-        console.log(red("ERROR: titan/bundle.js not found. Cannot bundle actions."));
-        process.exit(1);
-    }
+    /* Generate routes */
+    execSync(`node "${appJs}"`, { stdio: "inherit" });
 
-    // 3) Generate routes.json + action_map.json
-    console.log(cyan("→ Generating Titan metadata (routes + action_map)..."));
-    try {
-        execSync(`node app/app.js --build`, { stdio: "inherit" });
-    } catch (err) {
-        console.log(red("Failed to generate metadata via app/app.js"));
-        process.exit(1);
-    }
+    /* Bundle actions */
+    runBundler(root);
 
-    // 4) Bundle JS actions → .jsbundle files
-    console.log(cyan("→ Bundling Titan actions..."));
-    try {
-        execSync(`node titan/bundle.js`, { stdio: "inherit" });
-    } catch (err) {
-        console.log(red("Bundler failed. Check titan/bundle.js for errors."));
-        process.exit(1);
-    }
+    /* Copy bundles → server/actions */
+    const outDir = path.join(root, "server", "actions");
+    fs.mkdirSync(outDir, { recursive: true });
 
-    // 5) Ensure server/actions folder exists
-    const actionsOut = path.join(serverDir, "actions");
-    if (!fs.existsSync(actionsOut)) {
-        fs.mkdirSync(actionsOut, { recursive: true });
-    }
+    const builtActions = path.join(root, "titan", "actions");
 
-    // 6) Copy generated bundles into server/actions
-    const builtActions = path.join(projectRoot, "titan", "actions");
     if (fs.existsSync(builtActions)) {
         for (const file of fs.readdirSync(builtActions)) {
             if (file.endsWith(".jsbundle")) {
                 fs.copyFileSync(
                     path.join(builtActions, file),
-                    path.join(actionsOut, file)
+                    path.join(outDir, file)
                 );
             }
         }
     }
 
-    console.log(green("✔ Bundles copied to server/actions"));
+    console.log(green("✔ Actions copied to server/actions"));
 
-    // 7) Build Rust binary
-    console.log(cyan("→ Building Rust release binary..."));
-    try {
-        execSync(`cargo build --release`, {
-            cwd: serverDir,
-            stdio: "inherit",
-        });
-    } catch (err) {
-        console.log(red("Rust build failed."));
-        process.exit(1);
-    }
+    /* Rust release build */
+    execSync(`cargo build --release`, {
+        cwd: path.join(root, "server"),
+        stdio: "inherit",
+    });
 
-    console.log(green("✔ Titan production build complete!"));
-    console.log(green("✔ Rust binary ready at server/target/release/"));
+    console.log(green("✔ Rust binary built successfully."));
 }
 
-
-// START PRODUCTION
+/* START PRODUCTION BINARY */
 function startProd() {
-    const isWindows = process.platform === "win32";
-    const binaryName = isWindows ? "titan-server.exe" : "titan-server";
-
-    const exe = path.join(
-        process.cwd(),
-        "server",
-        "target",
-        "release",
-        binaryName
-    );
+    const isWin = process.platform === "win32";
+    const bin = isWin ? "titan-server.exe" : "titan-server";
 
+    const exe = path.join(process.cwd(), "server", "target", "release", bin);
     execSync(`"${exe}"`, { stdio: "inherit" });
 }
 
-// ------------------------------------------
-// TITAN UPDATE — Upgrade titan/ runtime
-// ------------------------------------------
+/* UPDATE TITAN */
 function updateTitan() {
-    const projectRoot = process.cwd();
-    const projectTitan = path.join(projectRoot, "titan");
+    const root = process.cwd();
+    const projectTitan = path.join(root, "titan");
 
     const cliTemplatesRoot = path.join(__dirname, "templates");
     const cliTitan = path.join(cliTemplatesRoot, "titan");
 
     if (!fs.existsSync(projectTitan)) {
-        console.log(red("No titan/ folder found in this project."));
-        console.log(yellow("Make sure you are inside a Titan project."));
+        console.log(red("Not a Titan project (titan/ missing)."));
         return;
     }
 
-
-    //
-    // 2. Replace titan/ runtime folder
-    //
     fs.rmSync(projectTitan, { recursive: true, force: true });
-    console.log(green("✔ Old titan/ runtime removed"));
-
     copyDir(cliTitan, projectTitan);
-    console.log(green("✔ titan/ runtime updated"));
-
-    //
-    // 3. Update server/Cargo.toml
-    //
-    const srcToml = path.join(cliTemplatesRoot, "server", "Cargo.toml");
-    const destToml = path.join(projectRoot, "server", "Cargo.toml");
-    if (fs.existsSync(srcToml)) {
-        fs.copyFileSync(srcToml, destToml);
-        console.log(green("✔ Updated server/Cargo.toml"));
-    }
-
-    //
-    // 4. Update ONLY server/src/main.rs
-    //
-    const srcMain = path.join(cliTemplatesRoot, "server", "src", "main.rs");
-    const destMain = path.join(projectRoot, "server", "src", "main.rs");
-    if (fs.existsSync(srcMain)) {
-        fs.copyFileSync(srcMain, destMain);
-        console.log(green("✔ Updated server/src/main.rs"));
-    }
-
-    //
-    // 5. Update root-level config files
-    //
-    [".gitignore", ".dockerignore", "Dockerfile"].forEach((file) => {
-        const src = path.join(cliTemplatesRoot, file);
-        const dest = path.join(projectRoot, file);
-
-        if (fs.existsSync(src)) {
-            fs.copyFileSync(src, dest);
-            console.log(green(`✔ Updated ${file}`));
-        }
-    });
 
-    console.log(cyan("✔ Titan forced update complete"));
+    console.log(green("✔ Titan runtime updated"));
 }
 
-
-
-
-
-
-// ROUTER
+/* ROUTER */
 switch (cmd) {
     case "init":
         initProject(args[1]);
@@ -369,7 +276,12 @@ switch (cmd) {
         updateTitan();
         break;
 
+    case "--version":
+    case "-v":
+    case "version":
+        console.log(green(`Titan v${TITAN_VERSION}`));
+        break;
+
     default:
         help();
 }
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "25.12.8",
+  "version": "25.13.0",
   "description": "JavaScript backend framework that compiles your JS into a Rust + Axum server.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/server/src/main.rs

@@ -186,12 +186,12 @@ async fn dynamic_handler_inner(
                         .into_response();
                 }
 
-                let action_path = state
-                    .project_root
-                    .join("server")
+                let action_path = state.project_root
                     .join("actions")
                     .join(format!("{}.jsbundle", action_name));
 
+
+
                 if !action_path.exists() {
                     return (
                         StatusCode::NOT_FOUND,