@titanpl/packet 1.0.0 → 1.4.0

package/README.md

@@ -0,0 +1,11 @@
+# @titanpl/packet
+
+The internal bundler and module packer for Titan Planet.
+
+## What it works (What it does)
+This library parses all your app routes, components, middleware, and logic paths, then packages them into a static `build` output layer consisting of metadata files and JavaScript assets. 
+
+## How it works
+This package is triggered whenever you run `titan init` or `titan build` from the `@titanpl/cli`. It hooks into tools like `esbuild` to optimize your scripts efficiently. It strips unnecessary pieces out so that only explicit route actions make their way aggressively over to the Titan runtime 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/index.js

@@ -1,9 +1,18 @@
 import path from "path";
 import fs from "fs";
 
-import { bundle as bundleActions } from "./js/titan/bundle.js";
-import { dev as devServer } from "./js/titan/dev.js";
-import { buildMetadata } from "./js/titan/builder.js";
+/**
+ * Get project type (js or ts)
+ */
+function getProjectType(root) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    if (pkg.titan && pkg.titan.template && pkg.titan.template.includes("ts")) return "ts";
+  } catch (e) { }
+
+  if (fs.existsSync(path.join(root, "tsconfig.json"))) return "ts";
+  return "js";
+}
 
 /**
  * Ensure dist directory exists
@@ -27,6 +36,10 @@ function ensureDist(root) {
  * Production build
  */
 export async function build(root = process.cwd()) {
+  const type = getProjectType(root);
+  const { bundle: bundleActions } = await import(`./${type}/titan/bundle.js`);
+  const { buildMetadata } = await import(`./${type}/titan/builder.js`);
+
   const dist = ensureDist(root);
 
   await buildMetadata(root, dist);
@@ -39,10 +52,13 @@ export async function build(root = process.cwd()) {
 }
 
 /**
- * Dev mode build (watch mode handled inside dev.js)
+ * Dev mode build
  */
 export async function dev(options = {}) {
   const root = typeof options === 'string' ? options : (options.root || process.cwd());
+  const type = getProjectType(root);
+  const { dev: devServer } = await import(`./${type}/titan/dev.js`);
+
   const dist = ensureDist(root);
 
   await devServer({
@@ -55,9 +71,14 @@ export async function dev(options = {}) {
 }
 
 /**
- * Direct export of lower-level tools (optional)
+ * Direct export of current project tools
  */
-export {
-  bundleActions,
-  buildMetadata
-};
+export async function getTools(root = process.cwd()) {
+  const type = getProjectType(root);
+  const bundleModule = await import(`./${type}/titan/bundle.js`);
+  const builderModule = await import(`./${type}/titan/builder.js`);
+  return {
+    bundleActions: bundleModule.bundle,
+    buildMetadata: builderModule.buildMetadata
+  };
+}

package/js/titan/builder.js

@@ -3,40 +3,17 @@ import path from "path";
 import { pathToFileURL } from "url";
 
 export async function buildMetadata(root, dist) {
-    const appJsPath = path.join(root, "app", "app.js");
-    const appTsPath = path.join(root, "app", "app.ts");
+    const appDir = path.join(root, "app");
+    const appFile = "app.js";
+    const appPath = path.join(appDir, appFile);
 
-    if (!fs.existsSync(appJsPath) && !fs.existsSync(appTsPath)) {
-        console.error("❌ app/app.js or app/app.ts not found.");
+    if (!fs.existsSync(appPath)) {
+        console.error(`\x1b[31m❌ app/${appFile} not found.\x1b[0m`);
         process.exit(1);
     }
 
-    // Load the app file to populate globalThis.__TITAN_ROUTES_MAP__
     try {
-        let appUrl;
-        if (fs.existsSync(appTsPath)) {
-            const dotTitan = path.join(root, ".titan");
-            const compiledApp = path.join(dotTitan, "app.js");
-
-            if (!fs.existsSync(dotTitan)) {
-                fs.mkdirSync(dotTitan, { recursive: true });
-            }
-
-            const esbuild = await import("esbuild");
-            await esbuild.build({
-                entryPoints: [appTsPath],
-                outfile: compiledApp,
-                bundle: true,
-                platform: "node",
-                format: "esm",
-                packages: "external",
-                logLevel: "silent"
-            });
-            appUrl = pathToFileURL(compiledApp).href;
-        } else {
-            appUrl = pathToFileURL(appJsPath).href;
-        }
-
+        const appUrl = pathToFileURL(appPath).href;
         const cacheBuster = `?t=${Date.now()}`;
         await import(appUrl + cacheBuster);
 
@@ -67,7 +44,7 @@ export async function buildMetadata(root, dist) {
         );
 
     } catch (err) {
-        console.error("❌ Failed to parse routes from app.js", err);
+        console.error("\x1b[31m❌ Failed to parse routes from app.js\x1b[0m", err);
         process.exit(1);
     }
 }

package/js/titan/bundle.js

@@ -1,7 +1,6 @@
 /**
- * Bundle.js
- * Handles esbuild bundling with comprehensive error reporting
- * RULE: This file handles ALL esbuild errors and prints error boxes directly
+ * Bundle.js (JavaScript Version)
+ * Handles esbuild bundling with error reporting
  */
 
 import esbuild from 'esbuild';
@@ -19,32 +18,21 @@ const require = createRequire(import.meta.url);
 
 /**
  * Titan Node Builtin Rewrite Map
- * Rewrites Node builtins to @titanpl/node shims
  */
 const NODE_BUILTIN_MAP = {
   "fs": "@titanpl/node/fs",
   "node:fs": "@titanpl/node/fs",
-
   "path": "@titanpl/node/path",
   "node:path": "@titanpl/node/path",
-
   "os": "@titanpl/node/os",
   "node:os": "@titanpl/node/os",
-
   "crypto": "@titanpl/node/crypto",
   "node:crypto": "@titanpl/node/crypto",
-
   "process": "@titanpl/node/process",
-
   "util": "@titanpl/node/util",
   "node:util": "@titanpl/node/util",
 };
 
-/**
- * Titan Node Compatibility Plugin
- * Rewrites require/import of Node builtins
- * Returns absolute paths (required by esbuild)
- */
 const titanNodeCompatPlugin = {
   name: "titan-node-compat",
   setup(build) {
@@ -54,30 +42,22 @@ const titanNodeCompatPlugin = {
           const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
           return { path: resolved };
         } catch (e) {
-          throw new Error(
-            `[Titan] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`
-          );
+          throw new Error(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
         }
       }
     });
   }
 };
 
-/**
- * Get Titan version for error branding
- */
 function getTitanVersion() {
   try {
-    const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+    const pkgPath = require.resolve("@titanpl/cli/package.json");
     return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
   } catch (e) {
-    return "0.1.0";
+    return "1.0.0";
   }
 }
 
-/**
- * Custom error class for bundle errors
- */
 export class BundleError extends Error {
   constructor(message, errors = [], warnings = []) {
     super(message);
@@ -88,26 +68,10 @@ export class BundleError extends Error {
   }
 }
 
-/**
- * Validate entry file exists
- */
 async function validateEntryPoint(entryPoint) {
   const absPath = path.resolve(entryPoint);
-
   if (!fs.existsSync(absPath)) {
-    throw new BundleError(
-      `Entry point does not exist: ${entryPoint}`,
-      [{ text: `Cannot find file: ${absPath}`, location: { file: entryPoint } }]
-    );
-  }
-
-  try {
-    await fs.promises.access(absPath, fs.constants.R_OK);
-  } catch {
-    throw new BundleError(
-      `Entry point is not readable: ${entryPoint}`,
-      [{ text: `Cannot read file: ${absPath}`, location: { file: entryPoint } }]
-    );
+    throw new BundleError(`Entry point does not exist: ${entryPoint}`, [{ text: `Cannot find file: ${absPath}`, location: { file: entryPoint } }]);
   }
 }
 
@@ -115,23 +79,12 @@ async function validateEntryPoint(entryPoint) {
  * Bundles a single file
  */
 export async function bundleFile(options) {
-  const {
-    entryPoint,
-    outfile,
-    format = 'iife',
-    minify = false,
-    sourcemap = false,
-    platform = 'neutral',
-    globalName = '__titan_exports',
-    target = 'es2020',
-    banner = {},
-    footer = {}
-  } = options;
+  const { entryPoint, outfile, format = 'iife', globalName = '__titan_exports', target = 'es2020' } = options;
 
   await validateEntryPoint(entryPoint);
 
   const outDir = path.dirname(outfile);
-  await fs.promises.mkdir(outDir, { recursive: true });
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
 
   try {
     const result = await esbuild.build({
@@ -140,63 +93,40 @@ export async function bundleFile(options) {
       outfile,
       format,
       globalName,
-      platform,
+      platform: 'node',
       target,
-      banner,
-      footer,
-      minify,
-      sourcemap,
       logLevel: 'silent',
-      logLimit: 0,
-      write: true,
-      metafile: false,
       plugins: [titanNodeCompatPlugin],
+      banner: { js: "var Titan = t;" },
+      footer: options.footer || {}
     });
 
     if (result.errors?.length) {
-      throw new BundleError(
-        `Build failed with ${result.errors.length} error(s)`,
-        result.errors,
-        result.warnings || []
-      );
+      throw new BundleError(`Build failed`, result.errors);
     }
-
   } catch (err) {
-    if (err.errors?.length) {
-      throw new BundleError(
-        `Build failed with ${err.errors.length} error(s)`,
-        err.errors,
-        err.warnings || []
-      );
-    }
-
-    throw new BundleError(
-      `Unexpected build error: ${err.message}`,
-      [{ text: err.message, location: { file: entryPoint } }]
-    );
+    if (err.errors) throw new BundleError(`Build failed`, err.errors);
+    throw err;
   }
 }
 
 /**
- * Main bundler
+ * Main JS Bundler
  */
 export async function bundle(options = {}) {
   const root = options.root || process.cwd();
   const outDir = options.outDir || path.join(root, 'dist');
+  const titanVersion = getTitanVersion();
 
   const actionsDir = path.join(root, 'app', 'actions');
   const bundleDir = path.join(outDir, 'actions');
 
-  if (fs.existsSync(bundleDir)) {
-    fs.rmSync(bundleDir, { recursive: true, force: true });
-  }
-  await fs.promises.mkdir(bundleDir, { recursive: true });
+  if (fs.existsSync(bundleDir)) fs.rmSync(bundleDir, { recursive: true, force: true });
+  fs.mkdirSync(bundleDir, { recursive: true });
 
   if (!fs.existsSync(actionsDir)) return;
 
-  const files = fs.readdirSync(actionsDir).filter(f =>
-    (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
-  );
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith('.js'));
 
   for (const file of files) {
     const actionName = path.basename(file, path.extname(file));
@@ -207,54 +137,27 @@ export async function bundle(options = {}) {
       await bundleFile({
         entryPoint,
         outfile,
-        format: 'iife',
-        globalName: '__titan_exports',
-        platform: 'node',
-        target: 'es2020',
-        banner: { js: "var Titan = t;" },
         footer: {
           js: `
 (function () {
-  const fn =
-    __titan_exports["${actionName}"] ||
-    __titan_exports.default;
-
-  if (typeof fn !== "function") {
-    throw new Error("[Titan] Action '${actionName}' not found or not a function");
-  }
-
+  const fn = __titan_exports["${actionName}"] || __titan_exports.default;
+  if (typeof fn !== "function") throw new Error("[TitanPL] Action '${actionName}' not found or not a function");
   globalThis["${actionName}"] = globalThis.defineAction(fn);
-})();
-`
+})();`
         }
       });
-
     } catch (error) {
-
       console.error();
-
-      const titanVersion = getTitanVersion();
-
       if (error.isBundleError && error.errors?.length) {
-        for (let i = 0; i < error.errors.length; i++) {
-          const errorInfo = parseEsbuildError(error.errors[i]);
-          if (error.errors.length > 1) {
-            errorInfo.title = `Build Error ${i + 1}/${error.errors.length}`;
-          }
+        for (const err of error.errors) {
+          const errorInfo = parseEsbuildError(err);
           errorInfo.titanVersion = titanVersion;
           console.error(renderErrorBox(errorInfo));
           console.error();
         }
       } else {
-        const errorInfo = {
-          title: 'Build Error',
-          file: entryPoint,
-          message: error.message || 'Unknown error',
-          titanVersion
-        };
-        console.error(renderErrorBox(errorInfo));
+        console.error(renderErrorBox({ title: 'Build Error', message: error.message, titanVersion }));
       }
-
       throw new Error('__TITAN_BUNDLE_FAILED__');
     }
   }

package/js/titan/dev.js

@@ -1,9 +1,11 @@
 import chokidar from "chokidar";
+import { spawn, execSync } from "child_process";
 import path from "path";
 import fs from "fs";
 import { bundle } from "./bundle.js";
 import { buildMetadata } from "./builder.js";
 import { createRequire } from "module";
+import os from "os";
 
 const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
 const green = (t) => `\x1b[32m${t}\x1b[0m`;
@@ -22,31 +24,94 @@ function getTitanVersion() {
     }
 }
 
-export async function dev(options) {
-    const root = options.root || process.cwd();
-    const outDir = options.outDir || path.join(root, "dist");
-    const onRebuild = options.onRebuild || (() => { });
+function getEngineBinaryPath(root) {
+    const platform = os.platform();
+    const arch = os.arch();
+    const binName = platform === 'win32' ? 'titan-server.exe' : 'titan-server';
+    const pkgName = `@titanpl/engine-${platform}-${arch}`;
 
-    const isTs = fs.existsSync(path.join(root, "tsconfig.json")) || fs.existsSync(path.join(root, "app", "app.ts"));
-    const actionsDir = path.join(root, "app", "actions");
-    let hasRust = false;
-    if (fs.existsSync(actionsDir)) {
-        hasRust = fs.readdirSync(actionsDir).some(f => f.endsWith(".rs"));
+    // Monorepo search
+    let current = root;
+    for (let i = 0; i < 5; i++) {
+        const potential = path.join(current, 'engine', 'target', 'release', binName);
+        if (fs.existsSync(potential)) return potential;
+        current = path.dirname(current);
     }
 
-    let mode = "";
-    if (hasRust) {
-        mode = isTs ? "Rust + TS Actions" : "Rust + JS Actions";
-    } else {
-        mode = isTs ? "TS Actions" : "JS Actions";
+    // Node modules search
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve(`${pkgName}/package.json`);
+        const binPath = path.join(path.dirname(pkgPath), 'bin', binName);
+        if (fs.existsSync(binPath)) return binPath;
+    } catch (e) { }
+
+    return null;
+}
+
+let serverProcess = null;
+
+async function killServer() {
+    if (!serverProcess) return;
+
+    return new Promise((resolve) => {
+        const onExit = () => {
+            serverProcess = null;
+            resolve();
+        };
+
+        serverProcess.on('exit', onExit);
+
+        if (os.platform() === 'win32') {
+            try {
+                execSync(`taskkill /pid ${serverProcess.pid} /f /t`, { stdio: 'ignore' });
+            } catch (e) { }
+        } else {
+            serverProcess.kill('SIGKILL');
+        }
+
+        setTimeout(onExit, 500);
+    });
+}
+
+function startServer(root, outDir) {
+    const binaryPath = getEngineBinaryPath(root);
+    if (!binaryPath) {
+        console.error(red("[TitanPL] Error: Could not find engine binary. Ensure you have installed the correct engine package."));
+        return;
     }
+
+    const distPath = path.resolve(root, "dist");
+
+    serverProcess = spawn(binaryPath, ['run', distPath, '--watch'], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            TITAN_ENV: 'development',
+            Titan_Dev: '1'
+        }
+    });
+
+    serverProcess.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+            console.error(red("[TitanPL] Failed to start engine: Binary not found."));
+        } else {
+            console.error(red(`[TitanPL] Engine error: ${err.message}`));
+        }
+    });
+}
+
+export async function dev(options) {
+    const root = options.root || process.cwd();
+    const outDir = options.outDir || path.join(root, "dist");
+
     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("Type:       ")} JS Actions`);
     console.log(`  ${gray("Hot Reload: ")} ${green("Enabled")}`);
 
     if (fs.existsSync(path.join(root, ".env"))) {
@@ -54,9 +119,25 @@ export async function dev(options) {
     }
     console.log("");
 
+    const runBuildCycle = async () => {
+        try {
+            await killServer();
+
+            await buildMetadata(root, outDir);
+            await bundle({ root, outDir });
+
+            console.log(cyan(`\n[TitanPL] Starting Engine...`));
+            startServer(root, outDir);
+        } catch (err) {
+            if (err.message !== '__TITAN_BUNDLE_FAILED__') {
+                console.error(red(`[TitanPL] Build failed: ${err.message}`));
+            }
+            console.log(yellow("\n[TitanPL] Waiting for fixes before restarting orbit..."));
+        }
+    };
+
     // Initial build
-    await buildMetadata(root, outDir);
-    await bundle({ root, outDir });
+    await runBuildCycle();
 
     // Watch for changes inside app/
     const appDir = path.join(root, "app");
@@ -64,21 +145,27 @@ export async function dev(options) {
 
     const watcher = chokidar.watch([appDir, envFile], {
         ignoreInitial: true,
-        awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
+        awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
     });
 
+    let buildTimer = null;
     watcher.on("all", async (event, file) => {
         if (!file) return;
         const relPath = path.relative(root, file);
-        if (relPath.startsWith("dist") || relPath.startsWith("server")) return;
+        if (relPath.startsWith("dist") || relPath.startsWith(".titan") || relPath.startsWith("server") || relPath.startsWith("node_modules")) return;
 
-        try {
-            await buildMetadata(root, outDir);
-            await bundle({ root, outDir });
-            onRebuild();
-        } catch (err) {
-            console.error(red(`[Titan] Build failed, awaiting changes...`));
-        }
+        if (buildTimer) clearTimeout(buildTimer);
+        buildTimer = setTimeout(() => {
+            console.clear();
+            console.log(cyan(`[TitanPL] File changed: ${relPath}. Rebuilding...`));
+            runBuildCycle();
+        }, 300); // Debounce
+    });
+
+    // Cleanup on exit
+    process.on('SIGINT', async () => {
+        await killServer();
+        process.exit(0);
     });
 
     return watcher;

package/js/titan/error-box.js

@@ -25,7 +25,7 @@ const red = (text) => `\x1b[31m${text}\x1b[0m`;
 function getTitanVersion() {
     try {
         const require = createRequire(import.meta.url);
-        const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+        const pkgPath = require.resolve("titanpl/package.json");
         return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
     } catch (e) {
         try {
@@ -34,7 +34,7 @@ function getTitanVersion() {
                 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;
+                    if (pkg.name === "titanpl") return pkg.version;
                 }
                 cur = path.join(cur, "..");
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/packet",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "description": "The bundler for TitanPl servers.",
   "keywords": [
     "bundler",
@@ -14,5 +14,10 @@
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "esbuild": "^0.27.2",
+    "chokidar": "^5.0.0",
+    "typescript": "^5.0.0"
   }
-}
+}