titanpl 1.0.0 → 1.4.0

package/packages/packet/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/packages/packet/index.js

@@ -0,0 +1,84 @@
+import path from "path";
+import fs from "fs";
+
+/**
+ * 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
+ */
+function ensureDist(root) {
+  const dist = path.join(root, "dist");
+  const actions = path.join(dist, "actions");
+
+  if (!fs.existsSync(dist)) {
+    fs.mkdirSync(dist, { recursive: true });
+  }
+
+  if (!fs.existsSync(actions)) {
+    fs.mkdirSync(actions, { recursive: true });
+  }
+
+  return dist;
+}
+
+/**
+ * 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);
+  await bundleActions({
+    root,
+    outDir: dist,
+  });
+
+  return dist;
+}
+
+/**
+ * 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({
+    root,
+    outDir: dist,
+    onRebuild: options.onRebuild
+  });
+
+  return dist;
+}
+
+/**
+ * Direct export of current project tools
+ */
+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/packages/packet/js/titan/builder.js

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+export async function buildMetadata(root, dist) {
+    const appDir = path.join(root, "app");
+    const appFile = "app.js";
+    const appPath = path.join(appDir, appFile);
+
+    if (!fs.existsSync(appPath)) {
+        console.error(`\x1b[31m❌ app/${appFile} not found.\x1b[0m`);
+        process.exit(1);
+    }
+
+    try {
+        const appUrl = pathToFileURL(appPath).href;
+        const cacheBuster = `?t=${Date.now()}`;
+        await import(appUrl + cacheBuster);
+
+        const config = globalThis.__TITAN_CONFIG__ || { port: 3000, threads: 4, stack_mb: 8 };
+        const routes = globalThis.__TITAN_ROUTES_MAP__ || {};
+        const dynamicRoutes = globalThis.__TITAN_DYNAMIC_ROUTES__ || {};
+        const actionMap = globalThis.__TITAN_ACTION_MAP__ || {};
+
+        const routesPath = path.join(dist, "routes.json");
+        const actionMapPath = path.join(dist, "action_map.json");
+
+        fs.writeFileSync(
+            routesPath,
+            JSON.stringify(
+                {
+                    __config: config,
+                    routes,
+                    __dynamic_routes: Object.values(dynamicRoutes).flat()
+                },
+                null,
+                2
+            )
+        );
+
+        fs.writeFileSync(
+            actionMapPath,
+            JSON.stringify(actionMap, null, 2)
+        );
+
+    } catch (err) {
+        console.error("\x1b[31m❌ Failed to parse routes from app.js\x1b[0m", err);
+        process.exit(1);
+    }
+}

package/packages/packet/js/titan/bundle.js

@@ -0,0 +1,164 @@
+/**
+ * Bundle.js (JavaScript Version)
+ * Handles esbuild bundling with error reporting
+ */
+
+import esbuild from 'esbuild';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { renderErrorBox, parseEsbuildError } from './error-box.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Required for resolving node_modules inside ESM
+const require = createRequire(import.meta.url);
+
+/**
+ * Titan Node Builtin Rewrite Map
+ */
+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",
+};
+
+const titanNodeCompatPlugin = {
+  name: "titan-node-compat",
+  setup(build) {
+    build.onResolve({ filter: /.*/ }, args => {
+      if (NODE_BUILTIN_MAP[args.path]) {
+        try {
+          const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
+          return { path: resolved };
+        } catch (e) {
+          throw new Error(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
+        }
+      }
+    });
+  }
+};
+
+function getTitanVersion() {
+  try {
+    const pkgPath = require.resolve("@titanpl/cli/package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+  } catch (e) {
+    return "1.0.0";
+  }
+}
+
+export class BundleError extends Error {
+  constructor(message, errors = [], warnings = []) {
+    super(message);
+    this.name = 'BundleError';
+    this.errors = errors;
+    this.warnings = warnings;
+    this.isBundleError = true;
+  }
+}
+
+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 } }]);
+  }
+}
+
+/**
+ * Bundles a single file
+ */
+export async function bundleFile(options) {
+  const { entryPoint, outfile, format = 'iife', globalName = '__titan_exports', target = 'es2020' } = options;
+
+  await validateEntryPoint(entryPoint);
+
+  const outDir = path.dirname(outfile);
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      outfile,
+      format,
+      globalName,
+      platform: 'node',
+      target,
+      logLevel: 'silent',
+      plugins: [titanNodeCompatPlugin],
+      banner: { js: "var Titan = t;" },
+      footer: options.footer || {}
+    });
+
+    if (result.errors?.length) {
+      throw new BundleError(`Build failed`, result.errors);
+    }
+  } catch (err) {
+    if (err.errors) throw new BundleError(`Build failed`, err.errors);
+    throw err;
+  }
+}
+
+/**
+ * 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 });
+  fs.mkdirSync(bundleDir, { recursive: true });
+
+  if (!fs.existsSync(actionsDir)) return;
+
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith('.js'));
+
+  for (const file of files) {
+    const actionName = path.basename(file, path.extname(file));
+    const entryPoint = path.join(actionsDir, file);
+    const outfile = path.join(bundleDir, actionName + ".jsbundle");
+
+    try {
+      await bundleFile({
+        entryPoint,
+        outfile,
+        footer: {
+          js: `
+(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();
+      if (error.isBundleError && error.errors?.length) {
+        for (const err of error.errors) {
+          const errorInfo = parseEsbuildError(err);
+          errorInfo.titanVersion = titanVersion;
+          console.error(renderErrorBox(errorInfo));
+          console.error();
+        }
+      } else {
+        console.error(renderErrorBox({ title: 'Build Error', message: error.message, titanVersion }));
+      }
+      throw new Error('__TITAN_BUNDLE_FAILED__');
+    }
+  }
+}

package/packages/packet/js/titan/dev.js

@@ -0,0 +1,172 @@
+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`;
+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 {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("@titanpl/cli/package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    } catch (e) {
+        return "1.0.0";
+    }
+}
+
+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}`;
+
+    // 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);
+    }
+
+    // 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:       ")} JS Actions`);
+    console.log(`  ${gray("Hot Reload: ")} ${green("Enabled")}`);
+
+    if (fs.existsSync(path.join(root, ".env"))) {
+        console.log(`  ${gray("Env:        ")} ${yellow("Loaded")}`);
+    }
+    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 runBuildCycle();
+
+    // Watch for changes inside app/
+    const appDir = path.join(root, "app");
+    const envFile = path.join(root, ".env");
+
+    const watcher = chokidar.watch([appDir, envFile], {
+        ignoreInitial: true,
+        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(".titan") || relPath.startsWith("server") || relPath.startsWith("node_modules")) return;
+
+        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;
+}