@ezetgalaxy/titan 26.7.4 → 26.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.7.4",
+  "version": "26.8.0",
   "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",
@@ -12,7 +12,6 @@
   },
   "files": [
     "index.js",
-    "scripts/",
     "templates/",
     "titan",
     "titanpl-sdk",
@@ -45,10 +44,12 @@
   ],
   "scripts": {
     "build": "echo \"No build step\"",
-    "test": "echo \"No tests specified\""
+    "test": "echo \"No tests specified\"",
+    "test_titan_init": "node scripts/test_titan_init.js"
   },
   "dependencies": {
     "chokidar": "^5.0.0",
-    "esbuild": "^0.27.2"
+    "esbuild": "^0.27.2",
+    "prompts": "^2.4.2"
   }
-}
+}

package/templates/js/_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/{package.json → js/package.json}

@@ -1,8 +1,11 @@
 {
-  "name": "{{name}}",
+  "name": "titanpl",
   "version": "1.0.0",
   "description": "A Titan Planet server",
   "type": "module",
+  "titan": {
+    "template": "js"
+  },
   "dependencies": {
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2"

package/templates/js/server/action_map.json

@@ -0,0 +1,3 @@
+{
+  "POST:/hello": "hello"
+}

package/templates/js/server/actions/hello.jsbundle

@@ -0,0 +1,48 @@
+const defineAction = (fn) => fn;
+var __titan_exports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // app/actions/hello.js
+  var hello_exports = {};
+  __export(hello_exports, {
+    hello: () => hello
+  });
+  var hello = (req) => {
+    return {
+      message: `Hello from Titan ${req.body.name}`
+    };
+  };
+  return __toCommonJS(hello_exports);
+})();
+
+    (function () {
+      const fn =
+        __titan_exports["hello"] ||
+        __titan_exports.default;
+    
+      if (typeof fn !== "function") {
+        throw new Error("[Titan] Action 'hello' not found or not a function");
+      }
+    
+      globalThis["hello"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
+    })();
+    

package/templates/js/server/routes.json

@@ -0,0 +1,16 @@
+{
+  "__config": {
+    "port": 3000
+  },
+  "routes": {
+    "POST:/hello": {
+      "type": "action",
+      "value": "hello"
+    },
+    "GET:/": {
+      "type": "text",
+      "value": "Ready to land on Titan Planet 🚀"
+    }
+  },
+  "__dynamic_routes": []
+}

package/templates/js/server/src/actions_rust/mod.rs

@@ -0,0 +1,15 @@
+// Auto-generated by Titan. Do not edit.
+use axum::response::IntoResponse;
+use axum::http::Request;
+use axum::body::Body;
+use std::future::Future;
+use std::pin::Pin;
+
+
+pub type ActionFn = fn(Request<Body>) -> Pin<Box<dyn Future<Output = axum::response::Response> + Send>>;
+
+pub fn get_action(name: &str) -> Option<ActionFn> {
+    match name {
+        _ => None
+    }
+}

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;