@ezetgalaxy/titan 26.7.5 → 26.8.0

package/templates/{server → js/server}/src/extensions.rs

@@ -3,6 +3,7 @@ use bcrypt::{DEFAULT_COST, hash, verify};
 use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode};
 use reqwest::{
     blocking::Client,
+    Method,
     header::{HeaderMap, HeaderName, HeaderValue},
 };
 use serde_json::Value;
@@ -18,6 +19,148 @@ use std::fs;
 use std::sync::Mutex;
 use walkdir::WalkDir;
 
+
+// ----------------------------------------------------------------------------
+// RUST ACTION API
+// ----------------------------------------------------------------------------
+
+pub struct T {
+    pub jwt: Jwt,
+    pub password: Password,
+}
+
+#[allow(non_upper_case_globals)]
+pub static t: T = T {
+    jwt: Jwt,
+    password: Password,
+};
+
+pub struct Jwt;
+impl Jwt {
+    pub fn sign(&self, payload: Value, secret: &str, options: Option<Value>) -> anyhow::Result<String> {
+        let mut final_payload = match payload {
+            Value::Object(map) => map,
+            _ => serde_json::Map::new(), // Should probably error or handle string payload like JS
+        };
+
+        if let Some(opts) = options {
+             if let Some(exp_val) = opts.get("expiresIn") {
+                // Handle both number (seconds) and string ("1h")
+                let seconds = if let Some(n) = exp_val.as_u64() {
+                    Some(n)
+                } else if let Some(s) = exp_val.as_str() {
+                    parse_expires_in(s)
+                } else {
+                    None
+                };
+
+                if let Some(sec) = seconds {
+                     let now = SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .unwrap()
+                        .as_secs();
+                    final_payload.insert("exp".to_string(), Value::Number(serde_json::Number::from(now + sec)));
+                }
+             }
+        }
+
+        let token = encode(
+            &Header::default(),
+            &Value::Object(final_payload),
+            &EncodingKey::from_secret(secret.as_bytes()),
+        )?;
+        Ok(token)
+    }
+
+    pub fn verify(&self, token: &str, secret: &str) -> anyhow::Result<Value> {
+        let mut validation = Validation::default();
+        validation.validate_exp = true; 
+
+        let data = decode::<Value>(
+            token,
+            &DecodingKey::from_secret(secret.as_bytes()),
+            &validation,
+        )?;
+        Ok(data.claims)
+    }
+}
+
+pub struct Password;
+impl Password {
+    pub fn hash(&self, password: &str) -> anyhow::Result<String> {
+        let h = hash(password, DEFAULT_COST)?;
+        Ok(h)
+    }
+
+    pub fn verify(&self, password: &str, hash_str: &str) -> bool {
+        verify(password, hash_str).unwrap_or(false)
+    }
+}
+
+impl T {
+    pub fn log(&self, msg: impl std::fmt::Display) {
+        println!(
+            "{} {}",
+            blue("[Titan]"),
+            gray(&format!("\x1b[90mlog(rust)\x1b[0m\x1b[97m: {}\x1b[0m", msg))
+        );
+    }
+
+    pub fn read(&self, path: &str) -> anyhow::Result<String> {
+        let root = std::env::current_dir()?;
+        let target = root.join(path);
+        let target = target.canonicalize()?;
+        Ok(fs::read_to_string(target)?)
+    }
+
+    pub async fn fetch(&self, url: &str, options: Option<FetchOptions>) -> anyhow::Result<FetchResponse> {
+        let client = reqwest::Client::new();
+        let opts = options.unwrap_or_default();
+        
+        let mut req = client.request(opts.method.parse().unwrap_or(Method::GET), url);
+
+        if let Some(headers) = opts.headers {
+            let mut map = HeaderMap::new();
+            for (k, v) in headers {
+                if let (Ok(name), Ok(val)) = (
+                    HeaderName::from_bytes(k.as_bytes()),
+                    HeaderValue::from_str(&v),
+                ) {
+                    map.insert(name, val);
+                }
+            }
+            req = req.headers(map);
+        }
+
+        if let Some(body) = opts.body {
+            req = req.body(body);
+        }
+
+        let res = req.send().await?;
+        let status = res.status().as_u16();
+        let text = res.text().await?;
+
+        Ok(FetchResponse {
+            status,
+            body: text,
+            ok: status >= 200 && status < 300
+        })
+    }
+}
+
+#[derive(Default)]
+pub struct FetchOptions {
+    pub method: String,
+    pub headers: Option<std::collections::HashMap<String, String>>,
+    pub body: Option<String>,
+}
+
+pub struct FetchResponse {
+    pub status: u16,
+    pub body: String,
+    pub ok: bool,
+}
+
 // ----------------------------------------------------------------------------
 // GLOBAL REGISTRY
 // ----------------------------------------------------------------------------
@@ -109,14 +252,16 @@ pub fn load_project_extensions(root: PathBuf) {
     search_dirs.sort();
     search_dirs.dedup();
 
-    println!("{} Scanning extension directories:", blue("[Titan]"));
+    // println!("{} Scanning extension directories:", blue("[Titan]"));
     for d in &search_dirs {
+        /*
         let label = if d.to_string_lossy().contains(".ext") {
              crate::utils::green("(Production)")
         } else {
              crate::utils::yellow("(Development)")
         };
         println!("   • {} {}", d.display(), label);
+        */
     }
 
     // =====================================================
@@ -245,20 +390,7 @@ pub fn load_project_extensions(root: PathBuf) {
     // 5. Store registry globally
     // =====================================================
     if modules.is_empty() {
-         println!("{} {}", blue("[Titan]"), crate::utils::yellow("No extensions loaded."));
-         // Debug: list files in search dirs to assist debugging
-         for dir in &search_dirs {
-             if dir.exists() {
-                 println!("{} Listing contents of {}:", blue("[Titan]"), dir.display());
-                 for entry in WalkDir::new(dir).max_depth(5) {
-                      if let Ok(e) = entry {
-                          println!("   - {}", e.path().display());
-                      }
-                 }
-             } else {
-                 println!("{} Directory not found: {}", blue("[Titan]"), dir.display());
-             }
-         }
+         // println!("{} {}", blue("[Titan]"), crate::utils::yellow("No extensions loaded."));
     }
 
     *REGISTRY.lock().unwrap() = Some(Registry {
@@ -333,7 +465,7 @@ fn native_read(
 
     // 3. Canonicalize (resolves ../)
     let target = match joined.canonicalize() {
-        Ok(t) => t,
+        Ok(target) => target,
         Err(_) => {
             throw(scope, &format!("t.read: file not found: {}", path_str));
             return;
@@ -554,7 +686,7 @@ fn native_jwt_sign(
     );
 
     match token {
-        Ok(t) => retval.set(v8_str(scope, &t).into()),
+        Ok(tok) => retval.set(v8_str(scope, &tok).into()),
         Err(e) => throw(scope, &e.to_string()),
     }
 }

package/templates/{titan → js/titan}/bundle.js

@@ -7,16 +7,28 @@ const actionsDir = path.join(root, "app", "actions");
 const outDir = path.join(root, "server", "actions");
 
 export async function bundle() {
-  console.log("[Titan] Bundling actions...");
+  const start = Date.now();
+  await bundleJs();
+  // console.log(`[Titan] Bundle finished in ${((Date.now() - start) / 1000).toFixed(2)}s`);
+}
+
+async function bundleJs() {
+  // console.log("[Titan] Bundling JS actions...");
 
   fs.mkdirSync(outDir, { recursive: true });
 
   // Clean old bundles
-  for (const file of fs.readdirSync(outDir)) {
-    fs.unlinkSync(path.join(outDir, file));
+  if (fs.existsSync(outDir)) {
+    const oldFiles = fs.readdirSync(outDir);
+    for (const file of oldFiles) {
+      fs.unlinkSync(path.join(outDir, file));
+    }
   }
 
   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...`);
 
   for (const file of files) {
     const actionName = path.basename(file, path.extname(file));
@@ -26,7 +38,7 @@ export async function bundle() {
     // Rust runtime expects `.jsbundle` extension — consistent with previous design
     const outfile = path.join(outDir, actionName + ".jsbundle");
 
-    console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+    // console.log(`[Titan] Bundling ${entry} → ${outfile}`);
 
     await esbuild.build({
       entryPoints: [entry],
@@ -36,6 +48,7 @@ export async function bundle() {
       globalName: "__titan_exports",
       platform: "neutral",
       target: "es2020",
+      logLevel: "silent",
       banner: {
         js: "const defineAction = (fn) => fn;"
       },
@@ -51,15 +64,15 @@ export async function bundle() {
         throw new Error("[Titan] Action '${actionName}' not found or not a function");
       }
     
-      globalThis["${actionName}"] = fn;
+      globalThis["${actionName}"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
     })();
     `
       }
     });
-
-
-
   }
 
-  console.log("[Titan] Bundling finished.");
+  // console.log("[Titan] JS Bundling finished.");
 }

package/templates/js/titan/dev.js

@@ -0,0 +1,194 @@
+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();

package/templates/{titan → js/titan}/titan.js

@@ -40,11 +40,30 @@ function addRoute(method, route) {
   };
 }
 
+/**
+ * @typedef {Object} RouteHandler
+ * @property {(value: any) => void} reply - Send a direct response
+ * @property {(name: string) => void} action - Bind to a server-side action
+ */
+
+/**
+ * Titan App Builder
+ */
 const t = {
+  /**
+   * Define a GET route
+   * @param {string} route 
+   * @returns {RouteHandler}
+   */
   get(route) {
     return addRoute("GET", route);
   },
 
+  /**
+   * Define a POST route
+   * @param {string} route 
+   * @returns {RouteHandler}
+   */
   post(route) {
     return addRoute("POST", route);
   },
@@ -53,6 +72,11 @@ const t = {
     console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
   },
 
+  /**
+   * Start the Titan Server
+   * @param {number} [port=3000] 
+   * @param {string} [msg=""] 
+   */
   async start(port = 3000, msg = "") {
     try {
       console.log(cyan("[Titan] Preparing runtime..."));
@@ -94,5 +118,5 @@ const t = {
   }
 };
 
-globalThis.t = t;
+
 export default t;

package/templates/rust/Dockerfile

@@ -0,0 +1,66 @@
+# ================================================================
+# STAGE 1 — Build Titan (JS → Rust)
+# ================================================================
+FROM rust:1.91.1 AS builder
+
+# Install Node for Titan CLI + bundler
+RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs
+
+# Install Titan CLI (latest)
+RUN npm install -g @ezetgalaxy/titan@latest
+
+WORKDIR /app
+
+# Copy project files
+COPY . .
+
+# Install JS dependencies (needed for Titan DSL + bundler)
+RUN npm install
+
+SHELL ["/bin/bash", "-c"]
+
+# Extract Titan extensions into .ext
+RUN mkdir -p /app/.ext && \
+    find /app/node_modules -maxdepth 5 -type f -name "titan.json" -print0 | \
+    while IFS= read -r -d '' file; do \
+    pkg_dir="$(dirname "$file")"; \
+    pkg_name="$(basename "$pkg_dir")"; \
+    echo "Copying Titan extension: $pkg_name from $pkg_dir"; \
+    cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
+    done && \
+    echo "Extensions in .ext:" && \
+    ls -R /app/.ext
+
+# Build Titan metadata + bundle JS actions
+RUN titan build
+
+# Build Rust binary
+RUN cd server && cargo build --release
+
+
+
+# ================================================================
+# STAGE 2 — Runtime Image (Lightweight)
+# ================================================================
+FROM debian:stable-slim
+
+WORKDIR /app
+
+# Copy Rust binary from builder stage
+COPY --from=builder /app/server/target/release/titan-server ./titan-server
+
+# Copy Titan routing metadata
+COPY --from=builder /app/server/routes.json ./routes.json
+COPY --from=builder /app/server/action_map.json ./action_map.json
+
+# Copy Titan JS bundles
+RUN mkdir -p /app/actions
+COPY --from=builder /app/server/actions /app/actions
+
+# Copy only Titan extensions
+COPY --from=builder /app/.ext ./.ext
+
+EXPOSE 3000
+
+CMD ["./titan-server"]

package/templates/rust/_dockerignore

@@ -0,0 +1,3 @@
+node_modules
+npm-debug.log
+.git

package/templates/rust/_gitignore

@@ -0,0 +1,37 @@
+# Node & Packages
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+package-lock.json
+yarn.lock
+
+# Titan Runtime (Auto-generated - DO NOT COMMIT)
+titan/server-bin*
+.ext/
+server/routes.json
+server/action_map.json
+server/actions/
+server/titan/
+server/src/actions_rust/
+
+# Rust Build Artifacts
+server/target/
+Cargo.lock
+
+# OS Files
+.DS_Store
+Thumbs.db
+*.tmp
+*.bak
+
+# Environment & Secrets
+.env
+.env.local
+.env.*.local
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo

package/templates/rust/app/actions/hello.js

@@ -0,0 +1,5 @@
+export const hello = (req) => {
+   return {
+        message: `Hello from Titan ${req.body.name}`,
+    };
+}

package/templates/rust/app/actions/rust_hello.rs

@@ -0,0 +1,14 @@
+use axum::{response::{IntoResponse, Json}, http::Request, body::Body};
+use serde_json::json;
+
+pub async fn run(_req: Request<Body>) -> impl IntoResponse {
+    // let _token = t.jwt.sign(json!({"id": 1}), "secret", Some(json!({"expiresIn": "1h"}))).unwrap_or_default();
+    // let decoded = t.jwt.verify(&_token, "secret").unwrap_or_default();
+
+    Json(json!({
+        "message": "Hello from Rust Action! 🦀",
+        "status": "blazing fast test",
+        // "token": _token,
+        // "decoded": decoded
+    }))
+}

package/templates/rust/app/app.js

@@ -0,0 +1,11 @@
+import t from "../titan/titan.js";
+
+
+
+
+t.post("/hello").action("hello") // pass a json payload { "name": "titan" }
+t.get("/rust").action("rust_hello") // This route uses a rust action
+
+t.get("/").reply("Ready to land on Titan Planet 🚀");
+
+t.start(3000, "Titan Running!");