@titanpl/cli 1.0.0

package/index.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { buildCommand } from "./src/commands/build.js";
+import { devCommand } from "./src/commands/dev.js";
+import { startCommand } from "./src/commands/start.js";
+import { migrateCommand } from "./src/commands/migrate.js";
+import { initCommand } from "./src/commands/init.js";
+
+/* -------------------------------------------------------
+ * Resolve __dirname (ESM safe)
+ * ----------------------------------------------------- */
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/* -------------------------------------------------------
+ * Colors (Old Titan Theme Style)
+ * ----------------------------------------------------- */
+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`;
+
+/* -------------------------------------------------------
+ * Version
+ * ----------------------------------------------------- */
+let VERSION = "1.0.0";
+
+try {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "package.json"), "utf8")
+  );
+  VERSION = pkg.version;
+} catch { }
+
+/* -------------------------------------------------------
+ * Help Output
+ * ----------------------------------------------------- */
+function help() {
+  console.log(`
+${bold(cyan("╭───────────────────────────────────────────────╮"))}
+${bold(cyan("│"))}  🪐 ${bold(cyan("Titan Planet"))} CLI                     ${gray(`v${VERSION}`.padEnd(6, ' '))} ${bold(cyan("│"))}
+${bold(cyan("╰───────────────────────────────────────────────╯"))}
+
+  ${yellow("Usage:")} ${bold("titan <command> [options]")}
+
+  ${bold("Commands:")}
+    ${cyan("init")}      ${gray("Scaffold a new Titan project")}
+    ${cyan("build")}     ${gray("Compile actions and build production dist")}
+    ${cyan("dev")}       ${gray("Start the Gravity Engine in dev/watch mode")}
+    ${cyan("start")}     ${gray("Start the production Gravity Engine")}
+    ${cyan("migrate")}   ${gray("Migrate a legacy project to the new architecture")}
+
+  ${bold("Options:")}
+    ${cyan("-v, --version")}  ${gray("Output the current version")}
+    ${cyan("-h, --help")}     ${gray("Display this help message")}
+
+${gray("  The Titan Planet Engine runs your JS/TS server natively without Node.js. ")}
+  ${cyan("https://titan-docs-ez.vercel.app")}
+`);
+}
+
+/* -------------------------------------------------------
+ * CLI Router
+ * ----------------------------------------------------- */
+const cmd = process.argv[2];
+
+(async () => {
+  try {
+    // -------------------------------------------------------
+    // Legacy Check
+    // -------------------------------------------------------
+    if (cmd !== 'migrate' && cmd !== 'init') {
+      const legacyCargo = path.join(process.cwd(), "server", "Cargo.toml");
+      if (fs.existsSync(legacyCargo)) {
+        console.log(yellow(`\n⚠️ This project uses legacy server architecture. Migration recommended.`));
+        console.log(`Please run: ${bold(cyan('titan migrate'))}\n`);
+        process.exit(1);
+      }
+    }
+
+    // -------------------------------------------------------
+    // Old tit / titan detection note
+    // -------------------------------------------------------
+    const scriptBase = path.basename(process.argv[1]);
+    if (scriptBase === 'tit') {
+      console.log(yellow(`\n⚠️ [Notice]: \`tit\` is deprecated. Please use \`titan\` instead.\n`));
+    }
+
+
+    switch (cmd) {
+      case "init": {
+        const projectName = process.argv[3];
+        let template = null;
+        const tIndex = process.argv.indexOf("-t") !== -1 ? process.argv.indexOf("-t") : process.argv.indexOf("--template");
+        if (tIndex !== -1 && process.argv[tIndex + 1]) {
+          template = process.argv[tIndex + 1];
+        }
+        await initCommand(projectName, template);
+        break;
+      }
+
+      case "build":
+        console.log(cyan("→ Building Titan project..."));
+        await buildCommand();
+        console.log(green("✔ Build complete"));
+        break;
+
+      case "dev":
+        await devCommand();
+        break;
+
+      case "start":
+        console.log(cyan("→ Starting Titan Server..."));
+        startCommand();
+        break;
+
+      case "migrate":
+        await migrateCommand();
+        break;
+
+      case "--version":
+      case "-v":
+      case "version":
+        console.log(cyan(`Titan CLI v${VERSION}`));
+        break;
+
+      default:
+        help();
+    }
+  } catch (err) {
+    console.error(red("✖ Titan CLI Error"));
+    console.error(gray(err?.message || err));
+    process.exit(1);
+  }
+})();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@titanpl/cli",
+  "version": "1.0.0",
+  "description": "The gravity and other builtins binary of TitanPl",
+  "keywords": [
+    "titanpl",
+    "titan",
+    "ezetgalaxy",
+    "cli"
+  ],
+  "license": "ISC",
+  "author": "ezetgalaxy",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "bin": {
+    "titan": "./index.js"
+  },
+  "optionalDependencies": {
+    "@titanpl/engine-win32-x64": "26.16.0",
+    "@titanpl/engine-linux-x64": "26.16.0",
+    "@titanpl/engine-darwin-arm64": "26.16.0"
+  },
+  "dependencies": {
+    "@titanpl/packet": "26.16.0",
+    "prompts": "^2.4.2",
+    "commander": "^11.0.0",
+    "chalk": "^4.1.2"
+  }
+}

package/src/commands/build.js

@@ -0,0 +1,6 @@
+import { build } from "@titanpl/packet";
+
+export async function buildCommand() {
+  const dist = await build(process.cwd());
+  console.log("✔ Build complete →", dist);
+}

package/src/commands/dev.js

@@ -0,0 +1,7 @@
+import { startEngine } from "../engine.js";
+
+export async function devCommand() {
+  // The Titan Engine now handles all compilation, watch, and routing natively.
+  // There is no need for JS-based watchers or Node.js process managers.
+  startEngine(true);
+}

package/src/commands/init.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import prompts from 'prompts';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function copyDir(src, dest, excludes = []) {
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const file of fs.readdirSync(src)) {
+        if (excludes.includes(file)) continue;
+
+        const srcPath = path.join(src, file);
+        const destPath = path.join(dest, file);
+
+        if (fs.lstatSync(srcPath).isDirectory()) {
+            copyDir(srcPath, destPath, excludes);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+export async function initCommand(projectName, templateName) {
+    let projName = projectName;
+
+    if (!projName) {
+        const res = await prompts({
+            type: 'text',
+            name: 'name',
+            message: 'Project name:',
+            initial: 'my-titan-app'
+        });
+        projName = res.name;
+    }
+
+    if (!projName) {
+        console.log(chalk.red("✖ Initialization cancelled."));
+        process.exit(1);
+    }
+
+    let selectedTemplate = templateName;
+
+    if (!selectedTemplate) {
+        const langRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select language:',
+            choices: [
+                { title: 'JavaScript', value: 'js' },
+                { title: 'TypeScript', value: 'ts' },
+            ],
+            initial: 0
+        });
+
+        if (!langRes.value) {
+            console.log(chalk.red("✖ Operation cancelled."));
+            process.exit(1);
+        }
+        const lang = langRes.value;
+
+        const archRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select template:',
+            choices: [
+                {
+                    title: `Standard (${lang.toUpperCase()})`,
+                    description: `Standard Titan app with ${lang.toUpperCase()} actions`,
+                    value: 'standard'
+                },
+                {
+                    title: `Rust + ${lang.toUpperCase()} (Hybrid)`,
+                    description: `High-performance Rust actions + ${lang.toUpperCase()} flexibility`,
+                    value: 'hybrid'
+                }
+            ],
+            initial: 0
+        });
+
+        if (!archRes.value) {
+            console.log(chalk.red("✖ Operation cancelled."));
+            process.exit(1);
+        }
+        const arch = archRes.value;
+
+        if (lang === 'js') {
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust-js';
+        } else {
+            selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
+        }
+    }
+
+    const target = path.resolve(process.cwd(), projName);
+    const templateDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', selectedTemplate);
+    const commonDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'common');
+
+    if (!fs.existsSync(templateDir) || !fs.existsSync(commonDir)) {
+        console.log(chalk.red(`✖ Error finding template paths.Are you in a valid Titan monorepo ? `));
+        process.exit(1);
+    }
+
+    if (fs.existsSync(target)) {
+        console.log(chalk.red(`✖ Directory '${projName}' already exists.`));
+        process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n→ Creating new Titan project in '${projName}'...\n`));
+
+    // 1. Copy common
+    copyDir(commonDir, target, ["_gitignore", "_dockerignore"]);
+
+    // 2. Copy specific template
+    copyDir(templateDir, target, ["_gitignore", "_dockerignore"]);
+
+    // 3. Dotfiles
+    const dotfiles = {
+        "_gitignore": ".gitignore",
+        "_dockerignore": ".dockerignore",
+        ".env": ".env"
+    };
+    for (const [srcName, destName] of Object.entries(dotfiles)) {
+        const src = path.join(commonDir, srcName);
+        const dest = path.join(target, destName);
+        if (fs.existsSync(src)) {
+            fs.copyFileSync(src, dest);
+        }
+    }
+
+    console.log(chalk.gray(`  Installing dependencies...`));
+
+    await new Promise((resolve, reject) => {
+        const npm = spawn('npm', ['install'], {
+            cwd: target,
+            stdio: 'inherit',
+            shell: true
+        });
+        npm.on('error', reject);
+        npm.on('close', resolve);
+    });
+
+    console.log(chalk.green(`\n✔ Project '${projName}' created successfully!\n`));
+    console.log(chalk.yellow(`  cd ${projName}`));
+    console.log(chalk.yellow(`  npm run dev\n`));
+}

package/src/commands/migrate.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function migrateCommand() {
+    const root = process.cwd();
+    console.log(`\n🔍 Checking project for legacy Titan architecture...`);
+
+    const serverDir = path.join(root, 'server');
+    const titanDir = path.join(root, 'titan');
+    const pkgPath = path.join(root, 'package.json');
+
+    if (!fs.existsSync(serverDir) && !fs.existsSync(titanDir)) {
+        console.log(`✅ This project is already using the modern Titan runtime architecture.`);
+        return;
+    }
+
+    console.log(`\n⚠️ Legacy server architecture detected. Migrating to runtime-first model...`);
+
+    // 1. Delete server/
+    if (fs.existsSync(serverDir)) {
+        console.log(`   Deleting legacy server/ folder...`);
+        fs.rmSync(serverDir, { recursive: true, force: true });
+    }
+
+    // 2. Delete titan/ folder
+    if (fs.existsSync(titanDir)) {
+        console.log(`   Deleting legacy titan/ runtime folder...`);
+        fs.rmSync(titanDir, { recursive: true, force: true });
+    }
+
+    // 3. Update package.json
+    if (fs.existsSync(pkgPath)) {
+        console.log(`   Updating package.json...`);
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            let modified = false;
+
+            // Update scripts
+            if (pkg.scripts) {
+                if (pkg.scripts.build && pkg.scripts.build.includes('cd server')) {
+                    pkg.scripts.build = "titan build";
+                    modified = true;
+                }
+                if (pkg.scripts.start && pkg.scripts.start.includes('cd server')) {
+                    pkg.scripts.start = "titan start";
+                    modified = true;
+                }
+                if (pkg.scripts.dev && pkg.scripts.dev.includes('titan/dev.js')) {
+                    pkg.scripts.dev = "titan dev";
+                    modified = true;
+                }
+            }
+
+            // Add dependencies
+            pkg.dependencies = pkg.dependencies || {};
+            if (!pkg.dependencies['@titan/native']) {
+                pkg.dependencies['@titan/native'] = "latest";
+                modified = true;
+            }
+            if (!pkg.dependencies['@titan/route']) {
+                pkg.dependencies['@titan/route'] = "latest";
+                modified = true;
+            }
+
+            if (modified) {
+                fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+            }
+        } catch (e) {
+            console.log(`   ⚠️ Failed to update package.json automatically. Please do it manually.`);
+        }
+    }
+
+    console.log(`\n🎉 Migration complete!`);
+    console.log(`   Please run 'npm install' to fetch the new dependencies.`);
+    console.log(`   Then run 'titan dev' to start your application.\n`);
+}

package/src/commands/start.js

@@ -0,0 +1,5 @@
+import { startEngine } from "../engine.js";
+
+export function startCommand() {
+  startEngine(false);
+}

package/src/engine.js

@@ -0,0 +1,76 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const require = createRequire(import.meta.url);
+
+export function getEngineBinaryPath() {
+  const platform = os.platform(); // 'win32', 'linux', 'darwin'
+  const arch = os.arch();         // 'x64', 'arm64'
+  const pkgName = `@titanpl/engine-${platform}-${arch}`;
+  const binName = platform === 'win32' ? 'titan-server.exe' : 'titan-server';
+
+  // 1. Monorepo Dev Fallback
+  const serverExeName = platform === 'win32' ? 'titan-server.exe' : 'titan-server';
+  const localFallback = path.resolve(__dirname, '..', '..', '..', 'engine', 'target', 'release', serverExeName);
+  if (fs.existsSync(localFallback)) {
+    return localFallback;
+  }
+
+  // 2. Resolve installed optional dependency
+  try {
+    const pkgPath = require.resolve(`${pkgName}/package.json`);
+    const pkgDir = path.dirname(pkgPath);
+    const binaryPath = path.join(pkgDir, 'bin', binName);
+
+    if (fs.existsSync(binaryPath)) {
+      return binaryPath;
+    }
+    throw new Error(`Corrupted installation: Binary missing at ${binaryPath}.`);
+  } catch (err) {
+    console.error(`\n[TITAN FATAL] Unsupported platform: ${platform} (${arch})`);
+    console.error(`Or the optional dependency '${pkgName}' failed to install.`);
+    console.error(`Error: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+
+export function startEngine(watchMode = false) {
+  const distPath = path.resolve(process.cwd(), 'dist');
+
+  if (!fs.existsSync(distPath)) {
+    console.error("❌ 'dist/' directory not found. Please run 'titan build' first.");
+    process.exit(1);
+  }
+
+  const binaryPath = getEngineBinaryPath();
+
+  // Arguments passed to Rust backend
+  const args = ['run', distPath];
+  if (watchMode) args.push('--watch');
+
+  console.log(`🚀 Starting Titan Engine...`);
+
+  const engineProcess = spawn(binaryPath, args, {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      TITAN_ENV: watchMode ? 'development' : 'production',
+      Titan_Dev: watchMode ? '1' : '0'
+    }
+  });
+
+  engineProcess.on('close', (code) => {
+    if (code !== 0 && code !== null && !engineProcess._isKilling) {
+      console.error(`\n❌ [Titan Engine died with exit code ${code}]`);
+    }
+  });
+
+  return engineProcess;
+}