@ezetgalaxy/titan 26.7.4 → 26.8.0

package/templates/rust/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/rust/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/titanpl-sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "titanpl-sdk",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
     "main": "index.js",
     "type": "module",

package/titanpl-sdk/templates/Dockerfile

@@ -18,20 +18,6 @@ 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
 
@@ -48,7 +34,7 @@ FROM debian:stable-slim
 WORKDIR /app
 
 # Copy Rust binary from builder stage
-COPY --from=builder /app/server/target/release/titan-server ./titan-server
+COPY --from=builder /app/server/target/release/server ./titan-server
 
 # Copy Titan routing metadata
 COPY --from=builder /app/server/routes.json ./routes.json
@@ -58,9 +44,10 @@ COPY --from=builder /app/server/action_map.json ./action_map.json
 RUN mkdir -p /app/actions
 COPY --from=builder /app/server/actions /app/actions
 
-# Copy only Titan extensions
-COPY --from=builder /app/.ext ./.ext
+COPY --from=builder /app/db /app/assets
 
+# Expose Titan port
 EXPOSE 3000
 
+# Start Titan
 CMD ["./titan-server"]