titanpl-sdk 2.0.3 → 2.0.4

package/templates/titan/bundle.js

@@ -1,264 +1,259 @@
-/**
- * Bundle.js
- * Handles esbuild bundling with comprehensive error reporting
- * RULE: This file handles ALL esbuild errors and prints error boxes directly
- */
-
-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);
-
-/**
- * Get Titan version for error branding
- */
-function getTitanVersion() {
-    try {
-        const require = createRequire(import.meta.url);
-        const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
-        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
-    } catch (e) {
-        return "0.1.0";
-    }
-}
-
-/**
- * Custom error class for bundle errors
- */
-export class BundleError extends Error {
-    constructor(message, errors = [], warnings = []) {
-        super(message);
-        this.name = 'BundleError';
-        this.errors = errors;
-        this.warnings = warnings;
-        this.isBundleError = true;
-    }
-}
-
-/**
- * Validates that the entry point exists and is readable
- * @param {string} entryPoint - Entry file path
- * @throws {BundleError} If file doesn't exist or isn't readable
- */
-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 (err) {
-        throw new BundleError(
-            `Entry point is not readable: ${entryPoint}`,
-            [{
-                text: `Cannot read file: ${absPath}`,
-                location: { file: entryPoint }
-            }]
-        );
-    }
-}
-
-/**
- * Bundles a single JavaScript/TypeScript file using esbuild
- * @param {Object} options - Bundle options
- * @returns {Promise<void>}
- * @throws {BundleError} If bundling fails
- */
-export async function bundleFile(options) {
-    const {
-        entryPoint,
-        outfile,
-        format = 'iife',
-        minify = false,
-        sourcemap = false,
-        platform = 'neutral',
-        globalName = '__titan_exports',
-        target = 'es2020',
-        banner = {},
-        footer = {}
-    } = options;
-
-    // Validate entry point exists
-    await validateEntryPoint(entryPoint);
-
-    // Ensure output directory exists
-    const outDir = path.dirname(outfile);
-    await fs.promises.mkdir(outDir, { recursive: true });
-
-    try {
-        // Run esbuild with error logging enabled
-        const result = await esbuild.build({
-            entryPoints: [entryPoint],
-            bundle: true,
-            outfile,
-            format,
-            globalName,
-            platform,
-            target,
-            banner,
-            footer,
-            minify,
-            sourcemap,
-            logLevel: 'silent', // We handle all errors ourselves
-            logLimit: 0,
-            color: false,
-            write: true,
-            metafile: false,
-        });
-
-        // Check for errors in the result
-        if (result.errors && result.errors.length > 0) {
-            throw new BundleError(
-                `Build failed with ${result.errors.length} error(s)`,
-                result.errors,
-                result.warnings || []
-            );
-        }
-
-    } catch (err) {
-        if (err.errors && err.errors.length > 0) {
-            // This is an esbuild error with detailed error information
-            throw new BundleError(
-                `Build failed with ${err.errors.length} error(s)`,
-                err.errors,
-                err.warnings || []
-            );
-        }
-
-        // Other unexpected errors
-        throw new BundleError(
-            `Unexpected build error: ${err.message}`,
-            [{
-                text: err.message,
-                location: { file: entryPoint }
-            }]
-        );
-    }
-}
-
-/**
- * Main bundle function - scans app/actions and bundles all files
- * RULE: This function handles ALL esbuild errors and prints error boxes directly
- * RULE: After printing error box, throws Error("__TITAN_BUNDLE_FAILED__")
- * @returns {Promise<void>}
- */
-export async function bundle() {
-    const root = process.cwd();
-    const actionsDir = path.join(root, 'app', 'actions');
-    const bundleDir = path.join(root, 'server', 'src', 'actions');
-
-    // Ensure bundle directory exists and is clean
-    if (fs.existsSync(bundleDir)) {
-        fs.rmSync(bundleDir, { recursive: true, force: true });
-    }
-    await fs.promises.mkdir(bundleDir, { recursive: true });
-
-    // Check if actions directory exists
-    if (!fs.existsSync(actionsDir)) {
-        return; // No actions to bundle
-    }
-
-    // Get all JS/TS files in actions directory
-    const files = fs.readdirSync(actionsDir).filter(f =>
-        (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
-    );
-
-    if (files.length === 0) {
-        return; // No action files
-    }
-
-    // Bundle each action file
-    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,
-                format: 'iife',
-                globalName: '__titan_exports',
-                platform: 'neutral',
-                target: 'es2020',
-                minify: false,
-                sourcemap: false,
-                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");
-  }
-
-  globalThis["${actionName}"] = globalThis.defineAction(fn);
-})();
-`
-                }
-            });
-        } catch (error) {
-            // RULE: Handle esbuild errors HERE and print error boxes
-            if (error.isBundleError && error.errors && error.errors.length > 0) {
-                // Print error box for each esbuild error
-                console.error(); // Empty line for spacing
-
-                const titanVersion = getTitanVersion();
-
-                for (let i = 0; i < error.errors.length; i++) {
-                    const esbuildError = error.errors[i];
-                    const errorInfo = parseEsbuildError(esbuildError);
-
-                    // Add error number to title if multiple errors
-                    if (error.errors.length > 1) {
-                        errorInfo.title = `Build Error ${i + 1}/${error.errors.length}`;
-                    }
-
-                    // Add Titan version
-                    errorInfo.titanVersion = titanVersion;
-
-                    // Print the error box
-                    console.error(renderErrorBox(errorInfo));
-
-                    if (i < error.errors.length - 1) {
-                        console.error(); // Empty line between errors
-                    }
-                }
-
-                console.error(); // Empty line after all errors
-            } else {
-                // Other errors
-                console.error();
-                const errorInfo = {
-                    title: 'Build Error',
-                    file: entryPoint,
-                    message: error.message || 'Unknown error',
-                    titanVersion: getTitanVersion()
-                };
-                console.error(renderErrorBox(errorInfo));
-                console.error();
-            }
-
-            // RULE: Throw special error to signal bundle failure
-            throw new Error('__TITAN_BUNDLE_FAILED__');
-        }
-    }
-}
+/**
+ * Bundle.js
+ * Handles esbuild bundling with comprehensive error reporting
+ * RULE: This file handles ALL esbuild errors and prints error boxes directly
+ */
+
+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
+ * 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) {
+    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(
+            `[Titan] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`
+          );
+        }
+      }
+    });
+  }
+};
+
+/**
+ * Get Titan version for error branding
+ */
+function getTitanVersion() {
+  try {
+    const pkgPath = require.resolve("titanpl/package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+  } catch (e) {
+    return "0.1.0";
+  }
+}
+
+/**
+ * Custom error class for bundle errors
+ */
+export class BundleError extends Error {
+  constructor(message, errors = [], warnings = []) {
+    super(message);
+    this.name = 'BundleError';
+    this.errors = errors;
+    this.warnings = warnings;
+    this.isBundleError = true;
+  }
+}
+
+/**
+ * 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 } }]
+    );
+  }
+}
+
+/**
+ * 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;
+
+  await validateEntryPoint(entryPoint);
+
+  const outDir = path.dirname(outfile);
+  await fs.promises.mkdir(outDir, { recursive: true });
+
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      outfile,
+      format,
+      globalName,
+      platform,
+      target,
+      banner,
+      footer,
+      minify,
+      sourcemap,
+      logLevel: 'silent',
+      logLimit: 0,
+      write: true,
+      metafile: false,
+      plugins: [titanNodeCompatPlugin],
+    });
+
+    if (result.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${result.errors.length} error(s)`,
+        result.errors,
+        result.warnings || []
+      );
+    }
+
+  } 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 } }]
+    );
+  }
+}
+
+/**
+ * Main bundler
+ */
+export async function bundle() {
+  const root = process.cwd();
+  const actionsDir = path.join(root, 'app', 'actions');
+  const bundleDir = path.join(root, 'server', 'src', 'actions');
+
+  if (fs.existsSync(bundleDir)) {
+    fs.rmSync(bundleDir, { recursive: true, force: true });
+  }
+  await fs.promises.mkdir(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')
+  );
+
+  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,
+        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");
+  }
+
+  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}`;
+          }
+          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));
+      }
+
+      throw new Error('__TITAN_BUNDLE_FAILED__');
+    }
+  }
+}

package/templates/titan/dev.js

@@ -25,7 +25,7 @@ const bold = (t) => `\x1b[1m${t}\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, "..");
             }
@@ -135,8 +135,8 @@ async function startRustServer(retryCount = 0) {
 
     serverProcess = spawn("cargo", ["run", "--quiet"], {
         cwd: serverPath,
-        stdio: ["ignore", "pipe", "pipe"], // Capture stderr to detect port conflicts
-        env: { ...process.env, CARGO_INCREMENTAL: "1" }
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, CARGO_INCREMENTAL: "1", TITAN_DEV: "1" }
     });
 
     serverProcess.on("error", (err) => {
@@ -195,17 +195,34 @@ async function startRustServer(retryCount = 0) {
                 stderrBuffer.includes("AddrInUse");
 
             if (isPortError) {
+                if (retryCount < 3) {
+                    // It's likely the previous process hasn't fully released the port
+                    await delay(1000);
+                    await startRustServer(retryCount + 1);
+                    return;
+                }
+
                 stopSpinner(false, "Orbit stabilization failed");
+
+                // Try to read intended port
+                let port = 3000;
+                try {
+                    const routesConfig = JSON.parse(fs.readFileSync(path.join(process.cwd(), "server", "routes.json"), "utf8"));
+                    if (routesConfig && routesConfig.__config && routesConfig.__config.port) {
+                        port = routesConfig.__config.port;
+                    }
+                } catch (e) { }
+
                 console.log("");
 
                 console.log(red("⏣  Your application cannot enter this orbit"));
-                console.log(red("↳  Another application is already bound to this port."));
+                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(3001, "Titan Running!")'));
+                console.log(yellow("     Example: ") + cyan(`t.start(${port + 1}, "Titan Running!")`));
                 console.log("");
 
                 return;
@@ -230,6 +247,28 @@ async function startRustServer(retryCount = 0) {
     });
 }
 
+function prepareRuntime() {
+    try {
+        const nm = path.join(process.cwd(), "node_modules");
+        const titanPkg = path.join(nm, "@titanpl");
+        const routePkg = path.join(titanPkg, "route");
+
+        if (!fs.existsSync(nm)) fs.mkdirSync(nm, { recursive: true });
+        if (!fs.existsSync(titanPkg)) fs.mkdirSync(titanPkg, { recursive: true });
+
+        if (!fs.existsSync(routePkg)) {
+            fs.mkdirSync(routePkg, { recursive: true });
+            fs.writeFileSync(path.join(routePkg, "package.json"), JSON.stringify({
+                name: "@titanpl/route",
+                main: "../../../titan/titan.js",
+                type: "module"
+            }, null, 2));
+        }
+    } catch (e) {
+        // Ignore errors
+    }
+}
+
 /**
  * Rebuild JS runtime
  * RULE: Only show "✖ Runtime preparation failed" on error
@@ -280,6 +319,7 @@ async function rebuild() {
 }
 
 async function startDev() {
+    prepareRuntime();
     const root = process.cwd();
     const actionsDir = path.join(root, "app", "actions");
     let hasRust = false;