titanpl 1.0.0 → 1.4.0

package/packages/cli/src/engine.js

@@ -0,0 +1,143 @@
+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. Robust Binary Discovery (Monorepo, Local, or Global)
+  const searchPaths = [
+    __dirname,
+    process.cwd(),
+    path.join(process.cwd(), '..'),
+    path.join(process.cwd(), '..', '..')
+  ];
+
+  for (let startPath of searchPaths) {
+    let current = startPath;
+    for (let i = 0; i < 8; i++) {
+      const potential = path.join(current, 'engine', 'target', 'release', binName);
+      if (fs.existsSync(potential)) return potential;
+
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+
+  // 2. Resolve installed optional dependency
+  try {
+    // We use a try/catch specifically for the resolve to provide a better diagnostic
+    let pkgPath;
+    try {
+      pkgPath = require.resolve(`${pkgName}/package.json`);
+    } catch (e) {
+      // Fallback: check if the binary exists in a standard location even if require.resolve fails
+      const fallbackBin = path.join(process.cwd(), 'node_modules', pkgName, 'bin', binName);
+      if (fs.existsSync(fallbackBin)) return fallbackBin;
+      throw e;
+    }
+    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', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      TITAN_ENV: watchMode ? 'development' : 'production',
+      Titan_Dev: watchMode ? '1' : '0'
+    }
+  });
+
+  let stderrBuffer = "";
+
+  engineProcess.stdout.pipe(process.stdout);
+  engineProcess.stderr.on('data', (data) => {
+    const chunk = data.toString();
+    stderrBuffer += chunk;
+    process.stderr.write(data);
+  });
+
+  engineProcess.on('close', (code) => {
+    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) {
+        // Try to read intended port
+        let port = 5100;
+        try {
+          const routesPath = path.join(process.cwd(), "dist", "routes.json");
+          if (fs.existsSync(routesPath)) {
+            const routesConfig = JSON.parse(fs.readFileSync(routesPath, "utf8"));
+            if (routesConfig && routesConfig.__config && routesConfig.__config.port) {
+              port = routesConfig.__config.port;
+            }
+          }
+        } catch (e) { }
+
+        const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+        const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+        const red = (t) => `\x1b[31m${t}\x1b[0m`;
+
+        console.log("");
+        console.log(red("⏣  Your application cannot enter this orbit"));
+        console.log(red(`↳  Another application is already bound to port ${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(${port + 1}, "Titan Running!")`));
+        console.log("");
+      } else {
+        console.error(`\n❌ [Titan Engine died with exit code ${code}]`);
+      }
+    }
+  });
+
+  return engineProcess;
+}

package/packages/engine-darwin-arm64/README.md

@@ -0,0 +1,13 @@
+# @titanpl/engine-darwin-arm64
+
+The macOS ARM64 pre-compiled native engine binary for Titan Planet.
+
+## What it works (What it does)
+This package is the compiled core Rust + Axum server embedded with the Boa JavaScript runtime. It is specifically built for Apple Silicon (ARM64) macOS devices.
+
+## How it works
+This package is listed as an "optional dependency" in `@titanpl/cli`. During package installation, your package manager identifies the OS and automatically downloads this binary if it matches `darwin` + `arm64`. You do not need to install it directly. 
+
+When you run `titan start`, the CLI locates this binary and executes it as your web server.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux and macOS versions are in development (dev only) for the new architecture and will be launched later.

package/packages/engine-darwin-arm64/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@titanpl/engine-darwin-arm64",
+  "version": "1.4.0",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ]
+}

package/packages/engine-linux-x64/README.md

@@ -0,0 +1,11 @@
+# @titanpl/engine-linux-x64
+
+The Linux x64 pre-compiled native engine binary for Titan Planet.
+
+## What it works (What it does)
+This package holds the core Rust + Axum high-performance web server tightly coupled with the Boa JavaScript execution runtime. It is built natively for Linux x64 environments, requiring no Node.js execution layer.
+
+## How it works
+You don't need to manually interact with this module. It acts as an optional dependency resolved by `#titanpl/cli`. If you run TitanPlanet on a Linux x64 machine, npm/yarn automatically downloads this native binary to run your application.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-linux-x64/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@titanpl/engine-linux-x64",
+  "version": "1.4.0",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

package/packages/engine-win32-x64/README.md

@@ -0,0 +1,11 @@
+# @titanpl/engine-win32-x64
+
+The Windows x64 pre-compiled native engine binary for Titan Planet.
+
+## What it works (What it does)
+This module provides the highly concurrent Rust-based server binary (`titan.exe`) powered by Axum and Boa. It removes the necessity of a Node.js event loop by only executing static routes in Rust and specific dynamic logic in embedded JavaScript.
+
+## How it works
+Like the other engine packages, this works entirely behind the scenes. When `@titanpl/cli` is installed on a Windows instance, it fetches this `.exe` runtime. The CLI then maps your built assets and JS routes into the binary for deployment.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-win32-x64/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@titanpl/engine-win32-x64",
+  "version": "1.4.0",
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ]
+}

package/packages/native/README.md

@@ -0,0 +1,11 @@
+# @titanpl/native
+
+The native utility extension module for Titan Planet.
+
+## What it works (What it does)
+It acts as the low-level communication bridge offering type definitions and utility wrappers out-of-the-box. Rather than being dependent on heavy JavaScript libraries, this package bridges Node-style features gracefully to the Titan runtime environment. 
+
+## How it works
+You can import tools and primitives from this package into your server-side actions alongside `@titanpl/core` when you want direct low-level interaction or need access to platform operations that interact directly with the C/Rust engine.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/native/index.d.ts

@@ -0,0 +1,41 @@
+export interface Request {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    params: Record<string, any>;
+    query: Record<string, any>;
+    body: any;
+}
+
+export interface FileSystem {
+    readFile(path: string, options?: any, callback?: (err: any, data: string) => void): string;
+    writeFile(path: string, data: string): void;
+    exists(path: string): boolean;
+    readdir(path: string): string[];
+    mkdir(path: string): void;
+    stat(path: string): any;
+}
+
+export const fs: FileSystem;
+export function log(message: any): void;
+export function defineAction<T = any>(handler: (req: Request) => T | Promise<T>): (req: Request) => T | Promise<T>;
+export function fetch(url: string, options?: any): any;
+export function drift<T>(op: any): T;
+
+// Add more as needed based on native/index.js
+export const db: any;
+export const path: any;
+export const jwt: any;
+export const password: any;
+export const crypto: any;
+export const buffer: any;
+export const ls: any;
+export const session: any;
+export const cookies: any;
+export const os: any;
+export const net: any;
+export const proc: any;
+export const time: any;
+export const url: any;
+export const response: any;
+export const valid: any;

package/packages/native/index.js

@@ -0,0 +1,39 @@
+// titan.js - Named exports for users who prefer imports over the global `t`
+
+export const fetch = t.fetch;
+export const log = t.log;
+export const read = t.read;
+
+// Authentication & Security
+export const jwt = t.jwt;
+export const password = t.password;
+
+// Database
+export const db = t.db;
+
+// File System & Path
+export const fs = t.fs;
+export const path = t.path;
+
+// Crypto & Buffer
+export const crypto = t.crypto;
+export const buffer = t.buffer;
+
+// Storage & Sessions
+export const ls = t.ls;
+export const localStorage = t.localStorage;
+export const session = t.session;
+export const cookies = t.cookies;
+
+// System
+export const os = t.os;
+export const net = t.net;
+export const proc = t.proc;
+
+// Utilities
+export const time = t.time;
+export const url = t.url;
+export const response = t.response;
+export const valid = t.valid;
+
+export const defineAction = (handler) => handler;

package/packages/native/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@titanpl/native",
+  "version": "1.4.0",
+  "description": "Titan native utilities package",
+  "type": "module",
+  "keywords": [
+    "titan",
+    "titanpl",
+    "t8n",
+    "native",
+    "utilities",
+    "ezetgalaxy"
+  ],
+  "main": "index.js",
+  "types": "./t.native.d.ts",
+  "exports": {
+    ".": {
+      "types": "./t.native.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "dependencies": {
+    "@titanpl/core": "1.4.0",
+    "@titanpl/node": "1.4.0"
+  }
+}