@ezetgalaxy/titan 26.9.0 → 26.9.2

package/README.md

@@ -44,6 +44,7 @@ Titan = **TS/JS productivity × Rust performance × Zero DevOps**
 | Zero-config Docker deploy            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 | Action-based architecture            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 | Hot reload dev server                | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Modular, Isolated Templates          | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 
 ---
 
@@ -59,15 +60,26 @@ npm install -g @ezetgalaxy/titan
 ```
 
 ### 3. Initialize & Run
+Titan guides you through selecting the perfect architecture for your needs.
+
 ```bash
 titan init my-app
-# Follow the interactive prompt to choose:
-# - JavaScript (Standard)
-# - TypeScript (Strict)
-# - Rust + JavaScript (Beta)
-# - Rust + TypeScript (Beta)
 ```
 
+**Select your language:**
+1.  `JavaScript` (Fast, lightweight)
+2.  `TypeScript` (Strict, typed)
+
+**Select your architecture:**
+1.  `Standard` (Pure JS/TS)
+2.  `Rust + JS/TS (Hybrid)` (High-performance native actions)
+
+This creates one of four isolated environments:
+*   **Standard JS:** Lightweight server, zero Rust overhead.
+*   **Standard TS:** Strict server, zero Rust overhead.
+*   **Hybrid JS:** Full Rust integration + JS flexibility.
+*   **Hybrid TS:** Full Rust integration + TS strictness.
+
 Inside your project:
 ```bash
 cd my-app
@@ -76,7 +88,7 @@ titan dev
 
 You'll see the Titan Dev Server spin up:
 ```
-  Titan Planet   v26.9.0   [ Dev Mode ]
+  Titan Planet   v26.9.1   [ Dev Mode ]
 
   Type:        Rust + TS Actions
   Hot Reload:  Enabled
@@ -93,34 +105,45 @@ You'll see the Titan Dev Server spin up:
 
 Titan is unique because it allows you to write endpoints in **JavaScript, TypeScript, and Rust** within the same project.
 
+| Feature | Status | Notes |
+| :--- | :--- | :--- |
+| **Standard JavaScript** | ✅ Stable | Production Ready |
+| **Standard TypeScript** | 🚧 Beta | **Ready for Dev**, Production Under Testing |
+| **Rust + JS (Hybrid)** | 🧪 Experimental | **Dev Only**, Production Under Testing |
+| **Rust + TS (Hybrid)** | 🧪 Experimental | **Dev Only**, Production Under Testing |
+
 ### 🔵 TypeScript Actions (`app/actions/hello.ts`)
 Fully typed, strict, and auto-compiled.
+
 ```typescript
-import { Context } from '@ezetgalaxy/titan';
+import { defineAction } from "../../titan/titan";
 
-export function run(req: Context) {
+interface HelloResponse {
+    message: string;
+    user_name: string;
+}
+
+// "defineAction" provides automatic type inference for "req"
+export const hello = defineAction((req): HelloResponse => {
     t.log("Handling request with strict types...");
-    
-    // Type checking allows safe property access
-    const user = req.body as { name: string };
-    
+
     return { 
         message: "Hello from TypeScript!",
-        user_name: user.name 
+        user_name: req.body.name || "Guest"
     };
-}
+});
 ```
 
 ### 🟡 JavaScript Actions (`app/actions/hello.js`)
 Perfect for business logic, rapid prototyping, and IO-bound tasks.
 ```javascript
-export function run(req) {
+export const hello = defineAction((req) => {
     t.log("Handling user request...");
     return { 
         message: "Hello from JavaScript!",
         user_id: req.params.id 
     };
-}
+});
 ```
 
 ### 🔴 Rust Actions (Beta)
@@ -212,4 +235,3 @@ Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript
 * Strict TypeScript Support
 * Native Rust Performance
 * Zero-Config Cloud Deployment
-

package/index.js

@@ -3,7 +3,7 @@ import prompts from "prompts";
 import fs from "fs";
 import path from "path";
 import { execSync, spawn } from "child_process";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 
 /* Resolve __dirname for ES modules */
 const __filename = fileURLToPath(import.meta.url);
@@ -12,17 +12,17 @@ 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 bold = (t) => `\x1b[1m${t}\x1b[0m`;
-const gray = (t) => `\x1b[90m${t}\x1b[0m`;
+export const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+export const green = (t) => `\x1b[32m${t}\x1b[0m`;
+export const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+export const red = (t) => `\x1b[31m${t}\x1b[0m`;
+export const bold = (t) => `\x1b[1m${t}\x1b[0m`;
+export const gray = (t) => `\x1b[90m${t}\x1b[0m`;
 
 /* -------------------------------------------------------
  * Invocation detection (tit vs titan)
  * ----------------------------------------------------- */
-function wasInvokedAsTit() {
+export function wasInvokedAsTit() {
     const script = process.argv[1];
     if (script) {
         const base = path.basename(script, path.extname(script)).toLowerCase();
@@ -51,7 +51,6 @@ function wasInvokedAsTit() {
 
     return false;
 }
-
 const isTitAlias = wasInvokedAsTit();
 
 if (isTitAlias) {
@@ -63,24 +62,25 @@ if (isTitAlias) {
     );
 }
 
-/* -------------------------------------------------------
- * Args
- * ----------------------------------------------------- */
-const args = process.argv.slice(2);
-const cmd = args[0];
-
 /* -------------------------------------------------------
  * Titan version
  * ----------------------------------------------------- */
-const pkg = JSON.parse(
-    fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
-);
-const TITAN_VERSION = pkg.version;
+let TITAN_VERSION = "0.1.0";
+try {
+    const pkg = JSON.parse(
+        fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
+    );
+    TITAN_VERSION = pkg.version;
+} catch (e) {
+    // Use default version
+}
+
+export { TITAN_VERSION };
 
 /* -------------------------------------------------------
  * Utils
  * ----------------------------------------------------- */
-function copyDir(src, dest, excludes = []) {
+export function copyDir(src, dest, excludes = []) {
     fs.mkdirSync(dest, { recursive: true });
 
     for (const file of fs.readdirSync(src)) {
@@ -103,26 +103,27 @@ function copyDir(src, dest, excludes = []) {
 /* -------------------------------------------------------
  * HELP
  * ----------------------------------------------------- */
-function help() {
+export function help() {
     console.log(`
-${bold(cyan("Titan Planet"))}  v${TITAN_VERSION}
+ ${bold(cyan("Titan Planet"))}  v${TITAN_VERSION}
 
-${green("titan init <project>")}   Create new Titan project
-${green("titan create ext <name>")} Create new Titan extension
-${green("titan dev")}              Dev mode (hot reload)
-${green("titan build")}            Build production Rust server
-${green("titan start")}            Start production binary
-${green("titan update")}           Update Titan engine
-${green("titan --version")}        Show Titan CLI version
+ ${green("titan init <project> [-t <template>]")}   Create new Titan project
+ ${green("titan create ext <name>")} Create new Titan extension
+ ${green("titan dev")}              Dev mode (hot reload)
+ ${green("titan build")}            Build production Rust server
+ ${green("titan start")}            Start production binary
+ ${green("titan update")}           Update Titan engine
+ ${green("titan --version")}        Show Titan CLI version
 
-${yellow("Note: `tit` is supported as a legacy alias.")}
+ ${yellow("Note: `tit` is supported as a legacy alias.")}
 `);
 }
 
 /* -------------------------------------------------------
  * INIT
  * ----------------------------------------------------- */
-async function initProject(name, templateName) {
+export async function initProject(name, templateName) {
+    // console.log(`DEBUG: initProject name=${name}, templateName=${templateName}`);
     let projName = name;
 
     if (!projName) {
@@ -150,7 +151,7 @@ async function initProject(name, templateName) {
             message: 'Select language:',
             choices: [
                 { title: 'JavaScript', value: 'js' },
-                { title: 'TypeScript', value: 'ts' }
+                { title: 'TypeScript', value: 'ts' },
             ],
             initial: 0
         });
@@ -188,7 +189,7 @@ async function initProject(name, templateName) {
         const arch = archRes.value;
 
         if (lang === 'js') {
-            selectedTemplate = arch === 'standard' ? 'js' : 'rust';
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust-js';
         } else {
             selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
         }
@@ -196,11 +197,16 @@ async function initProject(name, templateName) {
 
     const target = path.join(process.cwd(), projName);
     const templateDir = path.join(__dirname, "templates", selectedTemplate);
+    const commonDir = path.join(__dirname, "templates", "common");
 
     if (!fs.existsSync(templateDir)) {
         console.log(red(`Template '${selectedTemplate}' not found.`));
         return;
     }
+    if (!fs.existsSync(commonDir)) {
+        console.log(red(`Common template folder not found.`));
+        return;
+    }
 
     if (fs.existsSync(target)) {
         console.log(yellow(`Folder already exists: ${target}`));
@@ -212,12 +218,17 @@ async function initProject(name, templateName) {
     console.log(gray(`   Template: ${selectedTemplate}`));
 
     // ----------------------------------------------------------
-    // 1. Copy full template directory
+    // 1. Copy full COMMON directory
+    // ----------------------------------------------------------
+    copyDir(commonDir, target, ["_gitignore", "_dockerignore"]);
+
+    // ----------------------------------------------------------
+    // 2. Copy full SELECTED template directory
     // ----------------------------------------------------------
     copyDir(templateDir, target, ["_gitignore", "_dockerignore"]);
 
     // ----------------------------------------------------------
-    // 2. Explicitly install dotfiles
+    // 3. Explicitly install dotfiles from COMMON directory
     // ----------------------------------------------------------
     const dotfiles = {
         "_gitignore": ".gitignore",
@@ -225,7 +236,7 @@ async function initProject(name, templateName) {
     };
 
     for (const [srcName, destName] of Object.entries(dotfiles)) {
-        const src = path.join(templateDir, srcName);
+        const src = path.join(commonDir, srcName);
         const dest = path.join(target, destName);
 
         if (fs.existsSync(src)) {
@@ -233,10 +244,18 @@ async function initProject(name, templateName) {
         }
     }
 
-    // Dockerfile is safe as-is
-    const dockerfileSrc = path.join(templateDir, "Dockerfile");
-    if (fs.existsSync(dockerfileSrc)) {
-        fs.copyFileSync(dockerfileSrc, path.join(target, "Dockerfile"));
+    const pkgPath = path.join(target, "package.json");
+
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkgContent = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            if (!pkgContent.titan) pkgContent.titan = {};
+            pkgContent.titan.template = selectedTemplate;
+            fs.writeFileSync(pkgPath, JSON.stringify(pkgContent, null, 2));
+            console.log(gray(`   Metadata set: ${selectedTemplate}`));
+        } catch (e) {
+            console.log(yellow("⚠ Could not write template metadata to package.json"));
+        }
     }
 
     console.log(green("✔ Project structure created"));
@@ -263,7 +282,7 @@ async function initProject(name, templateName) {
 /* -------------------------------------------------------
  * DEV SERVER
  * ----------------------------------------------------- */
-async function devServer() {
+export async function devServer() {
     const root = process.cwd();
     const devScript = path.join(root, "titan", "dev.js");
 
@@ -289,25 +308,79 @@ async function devServer() {
 /* -------------------------------------------------------
  * BUILD
  * ----------------------------------------------------- */
-function buildProd() {
+export async function buildProd() {
     console.log(cyan("Titan: Building production output..."));
 
     const root = process.cwd();
     const appJs = path.join(root, "app", "app.js");
+    const appTs = path.join(root, "app", "app.ts");
     const serverDir = path.join(root, "server");
     const actionsOut = path.join(serverDir, "actions");
 
     // BASIC CHECKS
-    if (!fs.existsSync(appJs)) {
-        console.log(red("ERROR: app/app.js not found."));
+    if (!fs.existsSync(appJs) && !fs.existsSync(appTs)) {
+        console.log(red("ERROR: app/app.js or app/app.ts not found."));
         process.exit(1);
     }
 
+    // COMPILE TYPESCRIPT IF NEEDED
+    if (fs.existsSync(path.join(root, "tsconfig.json"))) {
+        console.log(cyan("→ Compiling TypeScript..."));
+        try {
+            // We use esbuild for speed and consistency with dev mode
+            const { buildSync } = await import("esbuild");
+            buildSync({
+                entryPoints: [path.join(root, "app", "app.ts")],
+                outfile: appJs,
+                bundle: true,
+                platform: "node",
+                format: "esm",
+                external: ["fs", "path", "esbuild", "chokidar", "typescript"],
+                packages: "external",
+            });
+            console.log(green("✔ TypeScript compiled"));
+        } catch (e) {
+            console.log(red("ERROR: Failed to compile TypeScript."));
+            console.error(e);
+            process.exit(1);
+        }
+    }
+
     // ----------------------------------------------------
-    // 1) BUILD METADATA + BUNDLE ACTIONS (ONE TIME ONLY)
+    // 1) BUILD METADATA + BUNDLE ACTIONS
     // ----------------------------------------------------
-    console.log(cyan("→ Building Titan metadata + bundling actions..."));
-    execSync("node app/app.js --build", { stdio: "inherit" });
+    console.log(cyan("→ Building Titan metadata..."));
+
+    // Si es TypeScript, compilar primero
+    if (fs.existsSync(appTs)) {
+        const dotTitan = path.join(root, ".titan");
+        const compiledApp = path.join(dotTitan, "app.js");
+
+        if (!fs.existsSync(dotTitan)) fs.mkdirSync(dotTitan, { recursive: true });
+
+        // Importar esbuild dinámicamente
+        const esbuild = await import("esbuild");
+        await esbuild.build({
+            entryPoints: [appTs],
+            outfile: compiledApp,
+            bundle: true,
+            platform: "node",
+            format: "esm",
+            packages: "external",
+            logLevel: "silent"
+        });
+
+        execSync(`node "${compiledApp}" --build`, { stdio: "inherit" });
+    } else {
+        execSync("node app/app.js --build", { stdio: "inherit" });
+    }
+
+    console.log(cyan("→ Bundling actions..."));
+    const bundlePath = path.join(root, "titan", "bundle.js");
+    // Convert Windows path to file:// URL for ESM import
+    const bundleUrl = pathToFileURL(bundlePath).href;
+    const { bundle } = await import(bundleUrl);
+    await bundle();
 
     // ensure actions directory exists
     fs.mkdirSync(actionsOut, { recursive: true });
@@ -315,9 +388,13 @@ function buildProd() {
     // verify bundled actions exist
     const bundles = fs.readdirSync(actionsOut).filter(f => f.endsWith(".jsbundle"));
     if (bundles.length === 0) {
-        console.log(red("ERROR: No actions bundled."));
-        console.log(red("Make sure your DSL outputs to server/actions."));
-        process.exit(1);
+        const rustActionsDir = path.join(serverDir, "src", "actions_rust");
+        const hasRustActions = fs.existsSync(rustActionsDir) &&
+            fs.readdirSync(rustActionsDir).some(f => f.endsWith(".rs") && f !== "mod.rs");
+
+        if (!hasRustActions) {
+            console.log(yellow("⚠ Warning: No JS or Rust actions found."));
+        }
     }
 
     bundles.forEach(file => {
@@ -330,37 +407,54 @@ function buildProd() {
     // 2) BUILD RUST BINARY
     // ----------------------------------------------------
     console.log(cyan("→ Building Rust release binary..."));
-    execSync("cargo build --release", {
-        cwd: serverDir,
-        stdio: "inherit"
-    });
 
-    console.log(green("✔ Titan production build complete!"));
+    // Only build rust if it's a rust project (check Cargo.toml)
+    if (fs.existsSync(path.join(serverDir, "Cargo.toml"))) {
+        execSync("cargo build --release", {
+            cwd: serverDir,
+            stdio: "inherit"
+        });
+        console.log(green("✔ Titan production build complete!"));
+    } else {
+        console.log(green("✔ Titan production build complete (pure JS/TS)!"));
+    }
 }
 
 /* -------------------------------------------------------
  * START
  * ----------------------------------------------------- */
-function startProd() {
+export function startProd() {
     const isWin = process.platform === "win32";
     const bin = isWin ? "titan-server.exe" : "titan-server";
+    const root = process.cwd();
 
-    const exe = path.join(process.cwd(), "server", "target", "release", bin);
-    execSync(`"${exe}"`, { stdio: "inherit" });
+    const exe = path.join(root, "server", "target", "release", bin);
+
+    if (fs.existsSync(exe)) {
+        execSync(`"${exe}"`, { stdio: "inherit" });
+    } else {
+        // Fallback to pure node start if no rust binary
+        const appJs = path.join(root, "app", "app.js");
+        // Actually, typically we run the bundled/compiled app if we don't have rust server?
+        // But wait, the pure TS template runs `node .titan/app.js` in Docker.
+        // But locally `titan start` relies on `app/app.js` being compiled?
+        // In `buildProd` above we compiled to `app/app.js`.
+        // Let's check for `.titan/app.js` which is dev artifact? No, use the prod build artifact.
+        execSync(`node "${appJs}"`, { stdio: "inherit" });
+    }
 }
 
 /* -------------------------------------------------------
  * UPDATE
  * ----------------------------------------------------- */
-
-function updateTitan() {
+export function updateTitan() {
     const root = process.cwd();
 
     const projectTitan = path.join(root, "titan");
     const projectServer = path.join(root, "server");
     const projectPkg = path.join(root, "package.json");
 
-    let templateType = "js"; // Default
+    let templateType = "js";
     if (fs.existsSync(projectPkg)) {
         try {
             const pkg = JSON.parse(fs.readFileSync(projectPkg, "utf-8"));
@@ -379,10 +473,8 @@ function updateTitan() {
         return;
     }
 
-    if (!fs.existsSync(templateServer)) {
-        console.log(red(`CLI seems corrupted or incomplete.`));
-        console.log(red(`Expected server template at: ${templateServer}`));
-        console.log(yellow(`If you are running from npx, try clearing cache or installing a specific version.`));
+    if (!fs.existsSync(templatesRoot)) {
+        console.log(red(`Template type '${templateType}' not found in CLI templates.`));
         return;
     }
 
@@ -391,15 +483,18 @@ function updateTitan() {
     // ----------------------------------------------------------
     // 1. Update titan/ runtime (authoritative, safe to replace)
     // ----------------------------------------------------------
-    fs.rmSync(projectTitan, {
-        recursive: true,
-        force: true,
-        maxRetries: 10,
-        retryDelay: 500,
-    });
-
-    copyDir(templateTitan, projectTitan);
-    console.log(green("✔ Updated titan/ runtime"));
+    if (fs.existsSync(templateTitan)) {
+        fs.rmSync(projectTitan, {
+            recursive: true,
+            force: true,
+            maxRetries: 10,
+            retryDelay: 500,
+        });
+        copyDir(templateTitan, projectTitan);
+        console.log(green("✔ Updated titan/ runtime"));
+    } else {
+        console.log(yellow(`⚠ No titan/ folder found in template '${templateType}', skipping.`));
+    }
 
     // ----------------------------------------------------------
     // 2. Update server/ WITHOUT deleting the folder
@@ -421,18 +516,19 @@ function updateTitan() {
     const projectSrc = path.join(projectServer, "src");
     const templateSrc = path.join(templateServer, "src");
 
-    if (fs.existsSync(projectSrc)) {
-        fs.rmSync(projectSrc, {
-            recursive: true,
-            force: true,
-            maxRetries: 10,
-            retryDelay: 500,
-        });
+    if (fs.existsSync(templateSrc)) {
+        if (fs.existsSync(projectSrc)) {
+            fs.rmSync(projectSrc, {
+                recursive: true,
+                force: true,
+                maxRetries: 10,
+                retryDelay: 500,
+            });
+        }
+        copyDir(templateSrc, projectSrc);
+        console.log(green("✔ Updated server/src/"));
     }
 
-    copyDir(templateSrc, projectSrc);
-    console.log(green("✔ Updated server/src/"));
-
     // Root-level config files
     const rootFiles = {
         "_gitignore": ".gitignore",
@@ -453,15 +549,16 @@ function updateTitan() {
 
     // app/titan.d.ts (JS typing contract)
     const appDir = path.join(root, "app");
-    const srcDts = path.join(templateServer, "../app/titan.d.ts"); // templates/app/titan.d.ts
+    const srcDts = path.join(templateServer, "../app/titan.d.ts");
+    const fallbackDts = path.join(templatesRoot, "app", "titan.d.ts");
+    const finalDtsSrc = fs.existsSync(srcDts) ? srcDts : (fs.existsSync(fallbackDts) ? fallbackDts : null);
     const destDts = path.join(appDir, "titan.d.ts");
 
-    if (fs.existsSync(srcDts)) {
+    if (finalDtsSrc) {
         if (!fs.existsSync(appDir)) {
             fs.mkdirSync(appDir);
         }
-
-        fs.copyFileSync(srcDts, destDts);
+        fs.copyFileSync(finalDtsSrc, destDts);
         console.log(green("✔ Updated app/titan.d.ts"));
     }
 
@@ -474,7 +571,7 @@ function updateTitan() {
 /* -------------------------------------------------------
  * CREATE EXTENSION
  * ----------------------------------------------------- */
-function createExtension(name) {
+export function createExtension(name) {
     if (!name) {
         console.log(red("Usage: titan create ext <name>"));
         return;
@@ -543,7 +640,7 @@ Next steps:
 `);
 }
 
-function runExtension() {
+export function runExtension() {
     const localSdk = path.join(__dirname, "titanpl-sdk", "bin", "run.js");
 
     if (fs.existsSync(localSdk)) {
@@ -566,35 +663,45 @@ function runExtension() {
 /* -------------------------------------------------------
  * ROUTER
  * ----------------------------------------------------- */
-// "titan create ext <name>" -> args = ["create", "ext", "calc_ext"]
-if (cmd === "create" && args[1] === "ext") {
-    createExtension(args[2]);
-} else if (cmd === "run" && args[1] === "ext") {
-    runExtension();
-} else {
-    switch (cmd) {
-        case "init": {
-            const projName = args[1];
-            let tpl = null;
-
-            const tIndex = args.indexOf("--template") > -1 ? args.indexOf("--template") : args.indexOf("-t");
-            if (tIndex > -1 && args[tIndex + 1]) {
-                tpl = args[tIndex + 1];
+const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
+
+if (isMainModule) {
+    const args = process.argv.slice(2);
+    // console.log("DEBUG: args", args);
+    const cmd = args[0];
+
+    (async () => {
+        // "titan create ext <name>" -> args = ["create", "ext", "calc_ext"]
+        if (cmd === "create" && args[1] === "ext") {
+            createExtension(args[2]);
+        } else if (cmd === "run" && args[1] === "ext") {
+            runExtension();
+        } else {
+            switch (cmd) {
+                case "init": {
+                    const projName = args[1];
+                    let tpl = null;
+
+                    const tIndex = args.indexOf("--template") > -1 ? args.indexOf("--template") : args.indexOf("-t");
+                    if (tIndex > -1 && args[tIndex + 1]) {
+                        tpl = args[tIndex + 1];
+                    }
+
+                    await initProject(projName, tpl);
+                    break;
+                }
+                case "dev": devServer(); break;
+                case "build": await buildProd(); break;
+                case "start": startProd(); break;
+                case "update": updateTitan(); break;
+                case "--version":
+                case "-v":
+                case "version":
+                    console.log(cyan(`Titan v${TITAN_VERSION}`));
+                    break;
+                default:
+                    help();
             }
-
-            initProject(projName, tpl);
-            break;
         }
-        case "dev": devServer(); break;
-        case "build": buildProd(); break;
-        case "start": startProd(); break;
-        case "update": updateTitan(); break;
-        case "--version":
-        case "-v":
-        case "version":
-            console.log(cyan(`Titan v${TITAN_VERSION}`));
-            break;
-        default:
-            help();
-    }
-}
+    })();
+}