@ezetgalaxy/titan 26.8.0 → 26.8.3

package/README.md

@@ -131,17 +131,8 @@ Both JS and Rust actions have access to the powerful `t` namespace:
 * `t.log(msg)` — Sandboxed, structured logging
 * `t.jwt.sign / verify` — Fast JWT operations
 * `t.password.hash / verify` — Secure password handling
-* `t.db` — Database access (coming soon)
-
-### 🛣 Intelligent Routing
-Define your routes in `routes.json`. Titan maps them to the correct action, regardless of language.
-
-```json
-{
-  "/hello": "hello",         // variable name matches filename (hello.js)
-  "/compute": "compute"      // variable name matches filename (compute.rs)
-}
-```
+* `t.db` — Database access
+---
 
 ### 🧩 Extensions System
 Extend the runtime with custom Rust engines using **Titan Extensions**.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.8.0",
+  "version": "26.8.3",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",
@@ -52,4 +52,4 @@
     "esbuild": "^0.27.2",
     "prompts": "^2.4.2"
   }
-}
+}

package/templates/js/server/src/main.rs

@@ -368,12 +368,7 @@ async fn main() -> Result<()> {
 
     let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
 
-    println!("\n\x1b[38;5;208m████████╗██╗████████╗ █████╗ ███╗   ██╗");
-    println!("╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║");
-    println!("   ██║   ██║   ██║   ███████║██╔██╗ ██║");
-    println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
-    println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
-    println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
+    
     println!(
         "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}",
         port

package/templates/js/titan/bundle.js

@@ -28,7 +28,7 @@ async function bundleJs() {
   const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".js") || f.endsWith(".ts"));
   if (files.length === 0) return;
 
-  console.log(`[Titan] Bundling ${files.length} JS actions...`);
+  // console.log(`[Titan] Bundling ${files.length} JS actions...`);
 
   for (const file of files) {
     const actionName = path.basename(file, path.extname(file));

package/templates/js/titan/dev.js

@@ -1,194 +1,282 @@
-import chokidar from "chokidar";
-import { spawn, execSync } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
-import fs from "fs";
-import { bundle } from "./bundle.js";
-
-// Required for __dirname in ES modules
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-
-// Colors
-import { createRequire } from "module";
-
-// 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`;
-const red = (t) => `\x1b[31m${t}\x1b[0m`;
-const gray = (t) => `\x1b[90m${t}\x1b[0m`;
-const bold = (t) => `\x1b[1m${t}\x1b[0m`;
-
-function getTitanVersion() {
-    try {
-        // 1. Try resolving from node_modules (standard user case)
-        const require = createRequire(import.meta.url);
-        // We look for @ezetgalaxy/titan/package.json
-        const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        return pkg.version;
-    } catch (e) {
-        try {
-            // 2. Fallback for local dev (path to repo root)
-            const localPath = path.join(__dirname, "..", "..", "..", "package.json");
-            if (fs.existsSync(localPath)) {
-                const pkg = JSON.parse(fs.readFileSync(localPath, "utf-8"));
-                if (pkg.name === "@ezetgalaxy/titan") {
-                    return pkg.version;
-                }
-            }
-        } catch (e2) { }
-    }
-    return "0.1.0"; // Fallback
-}
-
-let serverProcess = null;
-let isKilling = false;
-
-// ... (killServer same as before) 
-async function killServer() {
-    if (!serverProcess) return;
-
-    isKilling = true;
-    const pid = serverProcess.pid;
-    const killPromise = new Promise((resolve) => {
-        if (serverProcess.exitCode !== null) return resolve();
-        serverProcess.once("close", resolve);
-    });
-
-    if (process.platform === "win32") {
-        try {
-            execSync(`taskkill /pid ${pid} /f /t`, { stdio: 'ignore' });
-        } catch (e) {
-            // Ignore errors if process is already dead
-        }
-    } else {
-        serverProcess.kill();
-    }
-
-    try {
-        await killPromise;
-    } catch (e) { }
-    serverProcess = null;
-    isKilling = false;
-}
-
-async function startRustServer(retryCount = 0) {
-    const waitTime = retryCount > 0 ? 2000 : 1000;
-
-    await killServer();
-    await new Promise(r => setTimeout(r, waitTime));
-
-    const serverPath = path.join(process.cwd(), "server");
-    const startTime = Date.now();
-
-    if (retryCount > 0) {
-        console.log(yellow(`[Titan] Retrying Rust server (Attempt ${retryCount})...`));
-    }
-
-    serverProcess = spawn("cargo", ["run", "--jobs", "1"], {
-        cwd: serverPath,
-        stdio: "inherit",
-        shell: true,
-        env: { ...process.env, CARGO_INCREMENTAL: "0" }
-    });
-
-    serverProcess.on("close", async (code) => {
-        if (isKilling) return;
-        const runTime = Date.now() - startTime;
-        if (code !== 0 && code !== null && runTime < 15000 && retryCount < 5) {
-            await startRustServer(retryCount + 1);
-        } else if (code !== 0 && code !== null && retryCount >= 5) {
-            console.log(red(`[Titan] Server failed to start after multiple attempts.`));
-        }
-    });
-}
-
-async function rebuild() {
-    // process.stdout.write(gray("[Titan] Preparing runtime... "));
-    const start = Date.now();
-    try {
-        execSync("node app/app.js", { stdio: "ignore" });
-        await bundle();
-        // console.log(green("Done"));
-        const elapsed = ((Date.now() - start) / 1000).toFixed(1);
-        console.log(gray(`   A new orbit is ready for your app in ${elapsed}s`));
-        console.log(green(`   Your app is now orbiting Titan Planet`));
-    } catch (e) {
-        console.log(red("Failed"));
-        console.log(red("[Titan] Failed to prepare runtime. Check your app/app.js"));
-    }
-}
-
-async function startDev() {
-    const root = process.cwd();
-    // Check if Rust actions exist by looking for .rs files in app/actions
-    const actionsDir = path.join(root, "app", "actions");
-    let hasRust = false;
-    if (fs.existsSync(actionsDir)) {
-        hasRust = fs.readdirSync(actionsDir).some(f => f.endsWith(".rs"));
-    }
-
-    const mode = hasRust ? "Rust + JS Actions" : "JS Actions";
-    const version = getTitanVersion();
-
-    console.clear();
-    console.log("");
-    console.log(`  ${bold(cyan("Titan Planet"))}   ${gray("v" + version)}   ${yellow("[ Dev Mode ]")}`);
-    console.log("");
-    console.log(`  ${gray("Type:       ")} ${mode}`);
-    console.log(`  ${gray("Hot Reload: ")} ${green("Enabled")}`);
-
-    if (fs.existsSync(path.join(root, ".env"))) {
-        console.log(`  ${gray("Env:        ")} ${yellow("Loaded")}`);
-    }
-    console.log(""); // Spacer
-
-    // FIRST BUILD
-    try {
-        await rebuild();
-        await startRustServer();
-    } catch (e) {
-        console.log(red("[Titan] Initial build failed. Waiting for changes..."));
-    }
-
-    // ... watcher logic same as before but using color vars ...
-    const watcher = chokidar.watch(["app", ".env"], {
-        ignoreInitial: true,
-        awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
-    });
-
-    let timer = null;
-    watcher.on("all", async (event, file) => {
-        if (timer) clearTimeout(timer);
-        timer = setTimeout(async () => {
-            console.log(""); // Spacer before reload logs
-            if (file.includes(".env")) {
-                console.log(yellow("[Titan] Env Refreshed"));
-            } else {
-                console.log(cyan(`[Titan] Change: ${path.basename(file)}`));
-            }
-            try {
-                await killServer();
-                await rebuild();
-                await startRustServer();
-            } catch (e) {
-                console.log(red("[Titan] Build failed -- waiting for changes..."));
-            }
-        }, 1000);
-    });
-}
-
-// Handle graceful exit to release file locks
-async function handleExit() {
-    console.log("\n[Titan] Stopping server...");
-    await killServer();
-    process.exit(0);
-}
-
-process.on("SIGINT", handleExit);
-process.on("SIGTERM", handleExit);
-
-startDev();
+import chokidar from "chokidar";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+
+// Required for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+// Colors
+import { createRequire } from "module";
+
+// 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`;
+const red = (t) => `\x1b[31m${t}\x1b[0m`;
+const gray = (t) => `\x1b[90m${t}\x1b[0m`;
+const bold = (t) => `\x1b[1m${t}\x1b[0m`;
+
+function getTitanVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    } catch (e) {
+        try {
+            // Check levels up to find the framework root
+            let cur = __dirname;
+            for (let i = 0; i < 5; i++) {
+                const pkgPath = path.join(cur, "package.json");
+                if (fs.existsSync(pkgPath)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                    if (pkg.name === "@ezetgalaxy/titan") return pkg.version;
+                }
+                cur = path.join(cur, "..");
+            }
+        } catch (e2) { }
+
+        try {
+            // Fallback to calling tit --version
+            const output = execSync("tit --version", { encoding: "utf-8" }).trim();
+            const match = output.match(/v(\d+\.\d+\.\d+)/);
+            if (match) return match[1];
+        } catch (e3) { }
+    }
+    return "0.1.0";
+}
+
+let serverProcess = null;
+let isKilling = false;
+let isFirstBoot = true;
+
+// ... (killServer same as before) 
+async function killServer() {
+    if (!serverProcess) return;
+
+    isKilling = true;
+    const pid = serverProcess.pid;
+    const killPromise = new Promise((resolve) => {
+        if (serverProcess.exitCode !== null) return resolve();
+        serverProcess.once("close", resolve);
+    });
+
+    if (process.platform === "win32") {
+        try {
+            execSync(`taskkill /pid ${pid} /f /t`, { stdio: 'ignore' });
+        } catch (e) {
+            // Ignore errors if process is already dead
+        }
+    } else {
+        serverProcess.kill();
+    }
+
+    try {
+        await killPromise;
+    } catch (e) { }
+    serverProcess = null;
+    isKilling = false;
+}
+
+const delay = (ms) => new Promise(res => setTimeout(res, ms));
+
+let spinnerTimer = null;
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+let frameIdx = 0;
+
+function startSpinner(text) {
+    if (spinnerTimer) clearInterval(spinnerTimer);
+    process.stdout.write("\x1B[?25l"); // Hide cursor
+    spinnerTimer = setInterval(() => {
+        process.stdout.write(`\r  ${cyan(frames[frameIdx])} ${gray(text)}`);
+        frameIdx = (frameIdx + 1) % frames.length;
+    }, 80);
+}
+
+function stopSpinner(success = true, text = "") {
+    if (spinnerTimer) {
+        clearInterval(spinnerTimer);
+        spinnerTimer = null;
+    }
+    process.stdout.write("\r\x1B[K"); // Clear line
+    process.stdout.write("\x1B[?25h"); // Show cursor
+    if (text) {
+        if (success) {
+            console.log(`  ${green("✔")} ${green(text)}`);
+        } else {
+            console.log(`  ${red("✖")} ${red(text)}`);
+        }
+    }
+}
+
+async function startRustServer(retryCount = 0) {
+    const waitTime = retryCount > 0 ? 500 : 200;
+
+    await killServer();
+    await delay(waitTime);
+
+    const serverPath = path.join(process.cwd(), "server");
+    const startTime = Date.now();
+
+    startSpinner("Stabilizing your app on its orbit...");
+
+    let isReady = false;
+    let stdoutBuffer = "";
+    let buildLogs = "";
+
+    // If it takes more than 15s, update the message
+    const slowTimer = setTimeout(() => {
+        if (!isReady && !isKilling) {
+            startSpinner("Still stabilizing... (the first orbit takes longer)");
+        }
+    }, 15000);
+
+    serverProcess = spawn("cargo", ["run", "--quiet"], {
+        cwd: serverPath,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, CARGO_INCREMENTAL: "1" }
+    });
+
+    serverProcess.on("error", (err) => {
+        stopSpinner(false, "Failed to start orbit");
+        console.error(red(`[Titan] Error: ${err.message}`));
+    });
+
+    serverProcess.stderr.on("data", (data) => {
+        const str = data.toString();
+        if (isReady) {
+            process.stderr.write(data);
+        } else {
+            buildLogs += str;
+        }
+    });
+
+    serverProcess.stdout.on("data", (data) => {
+        const out = data.toString();
+
+        if (!isReady) {
+            stdoutBuffer += out;
+            if (stdoutBuffer.includes("Titan server running") || stdoutBuffer.includes("████████╗")) {
+                isReady = true;
+                clearTimeout(slowTimer);
+                stopSpinner(true, "Your app is now orbiting Titan Planet");
+
+                if (isFirstBoot) {
+                    process.stdout.write(stdoutBuffer);
+                    isFirstBoot = false;
+                } else {
+                    // On subsequent reloads, only print non-banner lines from the buffer
+                    const lines = stdoutBuffer.split("\n");
+                    for (const line of lines) {
+                        const isBanner = line.includes("Titan server running") ||
+                            line.includes("████████╗") ||
+                            line.includes("╚══") ||
+                            line.includes("   ██║") ||
+                            line.includes("   ╚═╝");
+                        if (!isBanner && line.trim()) {
+                            process.stdout.write(line + "\n");
+                        }
+                    }
+                }
+                stdoutBuffer = "";
+            }
+        } else {
+            process.stdout.write(data);
+        }
+    });
+
+    serverProcess.on("close", async (code) => {
+        clearTimeout(slowTimer);
+        if (isKilling) return;
+        const runTime = Date.now() - startTime;
+
+        if (code !== 0 && code !== null) {
+            stopSpinner(false, "Orbit stabilization failed");
+            if (!isReady) {
+                console.log(gray("\n--- Build Logs ---"));
+                console.log(buildLogs);
+                console.log(gray("------------------\n"));
+            }
+
+            if (runTime < 15000 && retryCount < 5) {
+                await delay(2000);
+                await startRustServer(retryCount + 1);
+            }
+        }
+    });
+}
+
+async function rebuild() {
+    try {
+        execSync("node app/app.js", { stdio: "ignore" });
+        // bundle is called inside app.js (t.start)
+    } catch (e) {
+        stopSpinner(false, "Failed to prepare runtime");
+        console.log(red(`[Titan] Error: ${e.message}`));
+    }
+}
+
+async function startDev() {
+    const root = process.cwd();
+    const actionsDir = path.join(root, "app", "actions");
+    let hasRust = false;
+    if (fs.existsSync(actionsDir)) {
+        hasRust = fs.readdirSync(actionsDir).some(f => f.endsWith(".rs"));
+    }
+
+    const mode = hasRust ? "Rust + JS Actions" : "JS Actions";
+    const version = getTitanVersion();
+
+    console.clear();
+    console.log("");
+    console.log(`  ${bold(cyan("Titan Planet"))}   ${gray("v" + version)}   ${yellow("[ Dev Mode ]")}`);
+    console.log("");
+    console.log(`  ${gray("Type:       ")} ${mode}`);
+    console.log(`  ${gray("Hot Reload: ")} ${green("Enabled")}`);
+
+    if (fs.existsSync(path.join(root, ".env"))) {
+        console.log(`  ${gray("Env:        ")} ${yellow("Loaded")}`);
+    }
+    console.log("");
+
+    try {
+        await rebuild();
+        await startRustServer();
+    } catch (e) {
+        // console.log(red("[Titan] Initial build failed. Waiting for changes..."));
+    }
+
+    const watcher = chokidar.watch(["app", ".env"], {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+    });
+
+    let timer = null;
+    watcher.on("all", async (event, file) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+            try {
+                await killServer();
+                await rebuild();
+                await startRustServer();
+            } catch (e) {
+                // console.log(red("[Titan] Build failed -- waiting for changes..."));
+            }
+        }, 300);
+    });
+}
+
+async function handleExit() {
+    stopSpinner();
+    console.log(gray("\n[Titan] Stopping server..."));
+    await killServer();
+    process.exit(0);
+}
+
+process.on("SIGINT", handleExit);
+process.on("SIGTERM", handleExit);
+
+startDev();

package/templates/rust/server/Cargo.toml

@@ -25,3 +25,15 @@ jsonwebtoken = "9"
 postgres = { version = "0.19", features = ["with-serde_json-1"] }
 libloading = "0.8"
 walkdir = "2"
+
+[profile.dev]
+opt-level = 0
+debug = 1
+incremental = true
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = true

package/templates/rust/server/src/main.rs

@@ -400,12 +400,6 @@ async fn main() -> Result<()> {
 
     let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
 
-    println!("\n\x1b[38;5;208m████████╗██╗████████╗ █████╗ ███╗   ██╗");
-    println!("╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║");
-    println!("   ██║   ██║   ██║   ███████║██╔██╗ ██║");
-    println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
-    println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
-    println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
     println!(
         "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}",
         port