@titanpl/cli 2.0.2 → 2.0.4

package/templates/rust-js/app/app.js

@@ -0,0 +1,9 @@
+import t from "@titanpl/route";
+
+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(5100, "Titan Running!");

package/templates/rust-js/eslint.config.js

@@ -0,0 +1,5 @@
+import { titanpl } from 'eslint-plugin-titanpl';
+
+export default [
+  titanpl
+];

package/templates/rust-js/jsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "checkJs": false,
+        "noImplicitAny": false,
+        "allowJs": true,
+        "moduleResolution": "node",
+        "baseUrl": ".",
+        "paths": {
+            "@titanpl/native": [
+                "app/t.native"
+            ],
+            "@titanpl/route": [
+                "./titan/titan"
+            ],
+            "*": [
+                "./app/*"
+            ]
+        }
+    },
+    "include": [
+        "app/**/*",
+        "titan/**/*",
+        "node_modules/**/titan-ext.d.ts"
+    ]
+}

package/templates/rust-js/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "titanpl",
+  "version": "2.0.4",
+  "description": "A Titan Planet server",
+  "type": "module",
+  "titan": {
+    "template": "rust-js"
+  },
+  "dependencies": {
+    "@titanpl/cli": "2.0.4",
+    "@titanpl/route": "2.0.4",
+    "@titanpl/native": "2.0.4",
+    "@titanpl/core": "latest",
+    "@titanpl/node": "latest"
+  },
+  "scripts": {
+    "build": "titan build",
+    "dev": "titan dev",
+    "start": "titan start",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.2",
+    "eslint-plugin-titanpl": "latest"
+  }
+}

package/templates/rust-js/titan/bundle.js

@@ -0,0 +1,157 @@
+import fs from "fs";
+import path from "path";
+import esbuild from "esbuild";
+
+const root = process.cwd();
+const actionsDir = path.join(root, "app", "actions");
+const outDir = path.join(root, "server", "actions");
+const rustOutDir = path.join(root, "server", "src", "actions_rust");
+
+export async function bundle() {
+  const start = Date.now();
+  await bundleJs();
+  await bundleRust();
+  // 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
+  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));
+
+    const entry = path.join(actionsDir, file);
+
+    // Rust runtime expects `.jsbundle` extension — consistent with previous design
+    const outfile = path.join(outDir, actionName + ".jsbundle");
+
+    // console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+
+    await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      format: "iife",
+      globalName: "__titan_exports",
+      platform: "neutral",
+      target: "es2020",
+      logLevel: "silent",
+      banner: {
+        js: "const defineAction = (fn) => fn; const Titan = t;"
+      },
+
+      footer: {
+        js: `
+    (function () {
+      const fn =
+        __titan_exports["${actionName}"] ||
+        __titan_exports.default;
+    
+      if (typeof fn !== "function") {
+        throw new Error("[Titan] Action '${actionName}' not found or not a function");
+      }
+    
+      globalThis["${actionName}"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
+    })();
+    `
+      }
+    });
+  }
+
+  // console.log("[Titan] JS Bundling finished.");
+}
+
+export async function bundleRust() {
+  // console.log("[Titan] Bundling Rust actions...");
+
+  if (!fs.existsSync(rustOutDir)) {
+    fs.mkdirSync(rustOutDir, { recursive: true });
+  }
+
+  // Clean old rust actions
+  for (const file of fs.readdirSync(rustOutDir)) {
+    fs.unlinkSync(path.join(rustOutDir, file));
+  }
+
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".rs"));
+  if (files.length > 0) {
+    // console.log(`[Titan] Bundling ${files.length} Rust actions...`);
+  }
+
+  const modules = [];
+
+  for (const file of files) {
+    const actionName = path.basename(file, ".rs");
+    const entry = path.join(actionsDir, file);
+    let outfile = path.join(rustOutDir, file);
+
+    let content = fs.readFileSync(entry, 'utf-8');
+
+    // Prepend implicit imports if not present
+    let finalContent = content;
+    if (!content.includes("use crate::extensions::t;")) {
+      finalContent = "use crate::extensions::t;\n" + content;
+    }
+
+    // Basic validation - check if it has a run function
+    if (!content.includes("async fn run")) {
+      console.warn(`[Titan] Warning: ${file} does not appear to have an 'async fn run'. It might fail to compile.`);
+    }
+
+    fs.writeFileSync(outfile, finalContent);
+    modules.push(actionName);
+    // console.log(`[Titan] Copied Rust action ${actionName}`);
+  }
+
+  // Generate mod.rs
+  let modContent = `// 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;
+
+`;
+
+  // Add mod declarations
+  for (const mod of modules) {
+    modContent += `pub mod ${mod};\n`;
+  }
+
+  modContent += `
+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 {
+`;
+
+  for (const mod of modules) {
+    modContent += `        "${mod}" => Some(|req| Box::pin(async move { 
+            ${mod}::run(req).await.into_response() 
+        })),\n`;
+  }
+
+  modContent += `        _ => None
+    }
+}
+`;
+
+  fs.writeFileSync(path.join(rustOutDir, "mod.rs"), modContent);
+  // console.log("[Titan] Rust Bundling finished.");
+}

package/templates/rust-js/titan/dev.js

@@ -0,0 +1,323 @@
+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("titanpl/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 === "titanpl") 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);
+        }
+    });
+
+    // Monitor stderr for port binding errors
+    serverProcess.stderr.on("data", (data) => {
+        stderrBuffer += data.toString();
+    });
+
+    serverProcess.on("close", async (code) => {
+        clearTimeout(slowTimer);
+        if (isKilling) return;
+        const runTime = Date.now() - startTime;
+
+        if (code !== 0 && code !== null) {
+            // Check for port binding errors
+            const isPortError = stderrBuffer.includes("Address already in use") ||
+                stderrBuffer.includes("address in use") ||
+                stderrBuffer.includes("os error 10048") || // Windows
+                stderrBuffer.includes("EADDRINUSE") ||
+                stderrBuffer.includes("AddrInUse");
+
+            if (isPortError) {
+                stopSpinner(false, "Orbit stabilization failed");
+                console.log("");
+
+                console.log(red("⏣  Your application cannot enter this orbit"));
+                console.log(red("↳  Another application is already bound to this port."));
+                console.log("");
+
+                console.log(yellow("Recommended Actions:"));
+                console.log(yellow("  1.") + " Release the occupied orbit (stop the other service).");
+                console.log(yellow("  2.") + " Assign your application to a new orbit in " + cyan("app/app.js"));
+                console.log(yellow("     Example: ") + cyan('t.start(3001, "Titan Running!")'));
+                console.log("");
+
+                return;
+            }
+
+
+            stopSpinner(false, "Orbit stabilization failed");
+
+            // Debug: Show stderr if it's not empty and not a port error
+            if (stderrBuffer && stderrBuffer.trim()) {
+                console.log(gray("\n[Debug] Cargo stderr:"));
+                console.log(gray(stderrBuffer.substring(0, 500))); // Show first 500 chars
+            }
+
+            if (runTime < 15000 && retryCount < maxRetries) {
+                await delay(2000);
+                await startRustServer(retryCount + 1);
+            } else if (retryCount >= maxRetries) {
+                console.log(gray("\n[Titan] Waiting for changes to retry..."));
+            }
+        }
+    });
+}
+
+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 isTs = fs.existsSync(path.join(root, "tsconfig.json")) ||
+        fs.existsSync(path.join(root, "app", "app.ts"));
+
+    let mode = "";
+    if (hasRust) {
+        mode = isTs ? "Rust + TS Actions" : "Rust + JS Actions";
+    } else {
+        mode = isTs ? "TS 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-js/titan/titan.js

@@ -0,0 +1,126 @@
+import fs from "fs";
+import path from "path";
+import { bundle } from "./bundle.js";
+
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+
+const routes = {};
+const dynamicRoutes = {};
+const actionMap = {};
+
+function addRoute(method, route) {
+  const key = `${method.toUpperCase()}:${route}`;
+
+
+  return {
+    reply(value) {
+      routes[key] = {
+        type: typeof value === "object" ? "json" : "text",
+        value
+      };
+    },
+
+    action(name) {
+      if (route.includes(":")) {
+        if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
+        dynamicRoutes[method].push({
+          method: method.toUpperCase(),
+          pattern: route,
+          action: name
+        });
+      } else {
+        routes[key] = {
+          type: "action",
+          value: name
+        };
+        actionMap[key] = name;
+      }
+    }
+  };
+}
+
+/**
+ * @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);
+  },
+
+  log(module, msg) {
+    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..."));
+      await bundle();
+
+      const base = path.join(process.cwd(), "server");
+      if (!fs.existsSync(base)) {
+        fs.mkdirSync(base, { recursive: true });
+      }
+
+      const routesPath = path.join(base, "routes.json");
+      const actionMapPath = path.join(base, "action_map.json");
+
+      fs.writeFileSync(
+        routesPath,
+        JSON.stringify(
+          {
+            __config: { port },
+            routes,
+            __dynamic_routes: Object.values(dynamicRoutes).flat()
+          },
+          null,
+          2
+        )
+      );
+
+      fs.writeFileSync(
+        actionMapPath,
+        JSON.stringify(actionMap, null, 2)
+      );
+
+      console.log(green("✔ Titan metadata written successfully"));
+      if (msg) console.log(cyan(msg));
+
+    } catch (e) {
+      console.error(`\x1b[31m[Titan] Build Error: ${e.message}\x1b[0m`);
+      process.exit(1);
+    }
+  }
+};
+
+
+/**
+ * Titan App Builder (Alias for t)
+ */
+export const Titan = t;
+export default t;

package/templates/rust-ts/app/actions/getuser.ts

@@ -0,0 +1,9 @@
+import { log, defineAction } from "@titanpl/native";
+
+export const getuser = defineAction((req: any) => {
+    log("Handling user request...");
+    return {
+        message: "Hello from TypeScript action!",
+        user_id: req.params.id
+    };
+});

package/templates/rust-ts/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
+    }))
+}