@ezetgalaxy/titan 26.8.2 → 26.9.0

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

@@ -0,0 +1,402 @@
+import chokidar from "chokidar";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import esbuild from "esbuild";
+import { createRequire } from "module";
+
+// Required for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+// 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;
+
+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) {
+    // If TS is broken, don't start
+    if (isTs && !isTsHealthy) {
+        stopSpinner(false, "Waiting for TypeScript errors to be fixed...");
+        return;
+    }
+
+    const waitTime = retryCount > 0 ? 1000 : 500;
+
+    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 30s, update the message
+    const slowTimer = setTimeout(() => {
+        if (!isReady && !isKilling) {
+            startSpinner("Still stabilizing... (the first orbit takes longer)");
+        }
+    }, 30000);
+
+    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() {
+    if (isTs && !isTsHealthy) return; // Don't rebuild if TS is broken
+
+    try {
+        const root = process.cwd();
+        const appTs = path.join(root, "app", "app.ts");
+        const dotTitan = path.join(root, ".titan");
+        const compiledApp = path.join(dotTitan, "app.js");
+
+        if (fs.existsSync(appTs)) {
+            if (!fs.existsSync(dotTitan)) fs.mkdirSync(dotTitan, { recursive: true });
+
+            await esbuild.build({
+                entryPoints: [appTs],
+                outfile: compiledApp,
+                bundle: true,
+                platform: "node",
+                format: "esm",
+                packages: "external",
+                logLevel: "silent"
+            });
+
+            execSync(`node "${compiledApp}"`, { stdio: "ignore" });
+        } else {
+            execSync("node app/app.js", { stdio: "ignore" });
+        }
+    } catch (e) {
+        stopSpinner(false, "Failed to prepare runtime");
+        console.log(red(`[Titan] Error: ${e.message}`));
+    }
+}
+
+let tsProcess = null;
+let isTsHealthy = false; // STRICT: Assume unhealthy until checked
+
+function startTypeChecker() {
+    const root = process.cwd();
+    if (!fs.existsSync(path.join(root, "tsconfig.json"))) return;
+
+    let tscPath;
+    try {
+        const require = createRequire(import.meta.url);
+        tscPath = require.resolve("typescript/bin/tsc");
+    } catch (e) {
+        tscPath = path.join(root, "node_modules", "typescript", "bin", "tsc");
+    }
+
+    if (!fs.existsSync(tscPath)) {
+        return;
+    }
+
+    const args = [tscPath, "--noEmit", "--watch", "--preserveWatchOutput", "--pretty"];
+
+    tsProcess = spawn(process.execPath, args, {
+        cwd: root,
+        stdio: "pipe",
+        shell: false
+    });
+
+    tsProcess.stdout.on("data", (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+            if (line.trim().includes("File change detected") || line.trim().includes("Starting compilation")) {
+                isTsHealthy = false;
+                continue;
+            }
+            if (line.includes("Found 0 errors")) {
+                isTsHealthy = true;
+                // TS is happy, so we rebuild and restart (or start) the server
+                rebuild().then(startRustServer);
+
+            } else if (line.includes("error TS")) {
+                isTsHealthy = false;
+                if (serverProcess) {
+                    console.log(red(`[Titan] TypeScript error detected. Stopping server...`));
+                    killServer();
+                }
+                process.stdout.write(line + "\n");
+            } else if (line.match(/Found [1-9]\d* error/)) {
+                isTsHealthy = false;
+                if (serverProcess) {
+                    console.log(red(`[Titan] TypeScript compilation failed. Stopping server...`));
+                    killServer();
+                }
+                process.stdout.write(line + "\n");
+            } else if (line.trim()) {
+                process.stdout.write(gray(`[TS] ${line}\n`));
+            }
+        }
+    });
+
+    tsProcess.stderr.on("data", (data) => {
+        process.stdout.write(data);
+    });
+}
+
+let isTs = false;
+
+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"));
+    }
+
+    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("");
+
+    if (isTs) {
+        startTypeChecker();
+    } else {
+        // If no TS, start immediately
+        try {
+            await rebuild();
+            await startRustServer();
+        } catch (e) {
+        }
+    }
+
+    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 () => {
+            // If TS, we rely on TCS to trigger the rebuild (via Found 0 errors)
+            // We verify path safety using absolute/relative calculations
+            const relPath = path.relative(root, file);
+            if (isTs && (relPath.startsWith("app") || relPath.startsWith("app" + path.sep))) return;
+
+            // If TS is broken, rebuild() checks will prevent update, keeping server dead
+            // If TS is healthy, we proceed
+            if (isTs && !isTsHealthy) return;
+
+            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();
+    if (tsProcess) {
+        if (process.platform === "win32") {
+            try { execSync(`taskkill /pid ${tsProcess.pid} /f /t`, { stdio: 'ignore' }); } catch (e) { }
+        } else {
+            tsProcess.kill();
+        }
+    }
+    process.exit(0);
+}
+
+process.on("SIGINT", handleExit);
+process.on("SIGTERM", handleExit);
+
+startDev();

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

@@ -0,0 +1,122 @@
+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);
+    }
+  }
+};
+
+
+export default t;

package/templates/rust-ts/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "*"
+            ]
+        }
+    },
+    "include": [
+        "app/**/*",
+        "titan/**/*"
+    ]
+}

package/templates/ts/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/ts/_dockerignore

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

package/templates/ts/_gitignore

@@ -0,0 +1,38 @@
+# 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*
+.titan/
+.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/ts/app/actions/hello.ts

@@ -0,0 +1,9 @@
+interface HelloResponse {
+    message: string;
+}
+
+export const hello = defineAction((req): HelloResponse => {
+    return {
+        message: `Hello from Titan ${req.body.name || "World"}`,
+    };
+});

package/templates/ts/app/app.ts

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