@titanpl/packet 1.0.0

package/js/titan/error-box.js

@@ -0,0 +1,277 @@
+/**
+ * Error Box Renderer
+ * Renders errors in a Next.js-style red terminal box
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Simple color function using ANSI escape codes
+const red = (text) => `\x1b[31m${text}\x1b[0m`;
+
+/**
+ * Wraps text to fit within a specified width
+ * @param {string} text - Text to wrap
+ * @param {number} maxWidth - Maximum width per line
+ * @returns {string[]} Array of wrapped lines
+ */
+
+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) {
+        try {
+            let cur = __dirname;
+            for (let i = 0; i < 5; i++) {
+                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;
+                }
+                cur = path.join(cur, "..");
+            }
+        } catch (e2) { }
+
+        try {
+            const output = execSync("tit --version", { encoding: "utf-8" }).trim();
+            const match = output.match(/v(\d+\.\d+\.\d+)/);
+            if (match) return match[1];
+        } catch (e3) { }
+    }
+    return "0.1.0";
+}
+
+function wrapText(text, maxWidth) {
+    if (!text) return [''];
+
+    const lines = text.split('\n');
+    const wrapped = [];
+
+    for (const line of lines) {
+        if (line.length <= maxWidth) {
+            wrapped.push(line);
+            continue;
+        }
+
+        // Word wrap logic
+        const words = line.split(' ');
+        let currentLine = '';
+
+        for (const word of words) {
+            const testLine = currentLine ? `${currentLine} ${word}` : word;
+
+            if (testLine.length <= maxWidth) {
+                currentLine = testLine;
+            } else {
+                if (currentLine) {
+                    wrapped.push(currentLine);
+                }
+                // If single word is too long, force split it
+                if (word.length > maxWidth) {
+                    let remaining = word;
+                    while (remaining.length > maxWidth) {
+                        wrapped.push(remaining.substring(0, maxWidth));
+                        remaining = remaining.substring(maxWidth);
+                    }
+                    currentLine = remaining;
+                } else {
+                    currentLine = word;
+                }
+            }
+        }
+
+        if (currentLine) {
+            wrapped.push(currentLine);
+        }
+    }
+
+    return wrapped.length > 0 ? wrapped : [''];
+}
+
+/**
+ * Pads text to fit within box width
+ * @param {string} text - Text to pad
+ * @param {number} width - Target width
+ * @returns {string} Padded text
+ */
+function padLine(text, width) {
+    const padding = width - text.length;
+    return text + ' '.repeat(Math.max(0, padding));
+}
+
+/**
+ * Renders an error in a Next.js-style red box
+ * @param {Object} errorInfo - Error information
+ * @param {string} errorInfo.title - Error title (e.g., "Build Error")
+ * @param {string} errorInfo.file - File path where error occurred
+ * @param {string} errorInfo.message - Error message
+ * @param {string} [errorInfo.location] - Error location (e.g., "at hello.js:3:1")
+ * @param {number} [errorInfo.line] - Line number
+ * @param {number} [errorInfo.column] - Column number
+ * @param {string} [errorInfo.codeFrame] - Code frame showing error context
+ * @param {string} [errorInfo.suggestion] - Recommended fix
+ */
+/**
+ * Renders an error in a Next.js-style red box
+ * @param {Object} errorInfo - Error information
+ * @param {string} errorInfo.title - Error title (e.g., "Build Error")
+ * @param {string} errorInfo.file - File path where error occurred
+ * @param {string} errorInfo.message - Error message
+ * @param {string} [errorInfo.location] - Error location (e.g., "at hello.js:3:1")
+ * @param {number} [errorInfo.line] - Line number
+ * @param {number} [errorInfo.column] - Column number
+ * @param {string} [errorInfo.codeFrame] - Code frame showing error context
+ * @param {string} [errorInfo.suggestion] - Recommended fix
+ */
+export function renderErrorBox(errorInfo) {
+    const boxWidth = 72;
+    const contentWidth = boxWidth - 4; // Account for "│ " and " │"
+
+    const lines = [];
+
+    // Add title
+    if (errorInfo.title) {
+        lines.push(bold(errorInfo.title));
+    }
+
+    // Add file path
+    if (errorInfo.file) {
+        lines.push(errorInfo.file);
+    }
+
+    // Add message
+    if (errorInfo.message) {
+        lines.push('');
+        lines.push(...wrapText(errorInfo.message, contentWidth));
+    }
+
+    // Add location
+    if (errorInfo.location) {
+        lines.push(gray(errorInfo.location));
+    } else if (errorInfo.file && errorInfo.line !== undefined) {
+        const loc = `at ${errorInfo.file}:${errorInfo.line}${errorInfo.column !== undefined ? `:${errorInfo.column}` : ''}`;
+        lines.push(gray(loc));
+    }
+
+    // Add code frame if available
+    if (errorInfo.codeFrame) {
+        lines.push(''); // Empty line for separation
+        const frameLines = errorInfo.codeFrame.split('\n');
+        for (const frameLine of frameLines) {
+            lines.push(frameLine);
+        }
+    }
+
+    // Add suggestion if available
+    if (errorInfo.suggestion) {
+        lines.push(''); // Empty line for separation
+        lines.push(...wrapText('Recommended fix: ' + errorInfo.suggestion, contentWidth));
+    }
+
+    // Add Footer with Branding
+    lines.push('');
+    const version = getTitanVersion()
+    lines.push(gray(`⏣ Titan Planet      ${version}`));
+
+    // Build the box
+    const topBorder = '┌' + '─'.repeat(boxWidth - 2) + '┐';
+    const bottomBorder = '└' + '─'.repeat(boxWidth - 2) + '┘';
+
+
+    const boxLines = [
+        red(topBorder),
+        ...lines.map(line => {
+            // Strip ANSI codes for padding calculation if any were added
+            const plainLine = line.replace(/\x1b\[\d+m/g, '');
+            const padding = ' '.repeat(Math.max(0, contentWidth - plainLine.length));
+            return red('│ ') + line + padding + red(' │');
+        }),
+        red(bottomBorder)
+    ];
+
+    return boxLines.join('\n');
+}
+
+// Internal formatting helpers
+function gray(t) { return `\x1b[90m${t}\x1b[0m`; }
+function bold(t) { return `\x1b[1m${t}\x1b[0m`; }
+
+/**
+ * Parses esbuild error and extracts relevant information
+ * @param {Object} error - esbuild error object
+ * @returns {Object} Parsed error information
+ */
+export function parseEsbuildError(error) {
+    const errorInfo = {
+        title: 'Build Error',
+        file: error.location?.file || 'unknown',
+        message: error.text || error.message || 'Unknown error',
+        line: error.location?.line,
+        column: error.location?.column,
+        location: null,
+        codeFrame: null,
+        suggestion: error.notes?.[0]?.text || null
+    };
+
+    // Format location
+    if (error.location) {
+        const { file, line, column } = error.location;
+        errorInfo.location = `at ${file}:${line}:${column}`;
+
+        // Format code frame if lineText is available
+        if (error.location.lineText) {
+            const lineText = error.location.lineText;
+            // Ensure column is at least 1 to prevent negative values
+            const col = Math.max(0, (column || 1) - 1);
+            const pointer = ' '.repeat(col) + '^';
+            errorInfo.codeFrame = `${line} | ${lineText}\n${' '.repeat(String(line).length)} | ${pointer}`;
+        }
+    }
+
+    return errorInfo;
+}
+
+/**
+ * Parses Node.js syntax error and extracts relevant information
+ * @param {Error} error - Node.js error object
+ * @param {string} [file] - File path (if known)
+ * @returns {Object} Parsed error information
+ */
+export function parseNodeError(error, file = null) {
+    const errorInfo = {
+        title: 'Syntax Error',
+        file: file || 'unknown',
+        message: error.message || 'Unknown error',
+        location: null,
+        suggestion: null
+    };
+
+    // Try to extract line and column from error message
+    const locationMatch = error.message.match(/\((\d+):(\d+)\)/) ||
+        error.stack?.match(/:(\d+):(\d+)/);
+
+    if (locationMatch) {
+        const line = parseInt(locationMatch[1]);
+        const column = parseInt(locationMatch[2]);
+        errorInfo.line = line;
+        errorInfo.column = column;
+        errorInfo.location = `at ${errorInfo.file}:${line}:${column}`;
+    }
+
+    // Extract suggestion from error message if available
+    if (error.message.includes('expected')) {
+        errorInfo.suggestion = 'Check for missing or misplaced syntax elements';
+    } else if (error.message.includes('Unexpected token')) {
+        errorInfo.suggestion = 'Remove or fix the unexpected token';
+    }
+
+    return errorInfo;
+}

package/js/titan/titan.js

@@ -0,0 +1,129 @@
+/**
+ * Titan.js
+ * Main Titan runtime builder
+ * RULE: This file does NOT handle esbuild errors - bundle.js handles those
+ */
+
+import fs from "fs";
+import path from "path";
+import { bundle } from "./bundle.js";
+
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+
+const routes = {};
+const dynamicRoutes = {};
+const actionMap = {};
+
+function addRoute(method, route) {
+  const key = `${method.toUpperCase()}:${route}`;
+
+  return {
+    reply(value) {
+      routes[key] = {
+        type: typeof value === "object" ? "json" : "text",
+        value
+      };
+    },
+
+    action(name) {
+      if (route.includes(":")) {
+        if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
+        dynamicRoutes[method].push({
+          method: method.toUpperCase(),
+          pattern: route,
+          action: name
+        });
+      } else {
+        routes[key] = {
+          type: "action",
+          value: name
+        };
+        actionMap[key] = name;
+      }
+    }
+  };
+}
+
+/**
+ * Titan App Builder
+ */
+const t = {
+  /**
+   * Define a GET route
+   */
+  get(route) {
+    return addRoute("GET", route);
+  },
+
+  /**
+   * Define a POST route
+   */
+  post(route) {
+    return addRoute("POST", route);
+  },
+
+  log(module, msg) {
+    console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
+  },
+
+  /**
+   * Start the Titan Server
+   * RULE: Only calls bundle() - does NOT handle esbuild errors
+   * RULE: If bundle throws __TITAN_BUNDLE_FAILED__, stop immediately without printing
+   */
+  async start(port = 3000, msg = "", threads, stack_mb = 8) {
+    try {
+      console.log(cyan("[Titan] Preparing runtime..."));
+
+      // RULE: Just call bundle() - it handles its own errors
+      await bundle();
+
+      const base = path.join(process.cwd(), "server");
+      if (!fs.existsSync(base)) {
+        fs.mkdirSync(base, { recursive: true });
+      }
+
+      const routesPath = path.join(base, "routes.json");
+      const actionMapPath = path.join(base, "action_map.json");
+
+      fs.writeFileSync(
+        routesPath,
+        JSON.stringify(
+          {
+            __config: { port, threads, stack_mb },
+            routes,
+            __dynamic_routes: Object.values(dynamicRoutes).flat()
+          },
+          null,
+          2
+        )
+      );
+
+      fs.writeFileSync(
+        actionMapPath,
+        JSON.stringify(actionMap, null, 2)
+      );
+
+      console.log(green("✔ Titan metadata written successfully"));
+      if (msg) console.log(cyan(msg));
+
+    } catch (e) {
+      // RULE: If bundle threw __TITAN_BUNDLE_FAILED__, just re-throw it
+      // The error box was already printed by bundle.js
+      if (e.message === '__TITAN_BUNDLE_FAILED__') {
+        throw e;
+      }
+
+      // Other unexpected errors (not from bundle)
+      console.error(`\x1b[31m[Titan] Unexpected error: ${e.message}\x1b[0m`);
+      throw e;
+    }
+  }
+};
+
+/**
+ * Titan App Builder (Alias for t)
+ */
+export const Titan = t;
+export default t;

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@titanpl/packet",
+  "version": "1.0.0",
+  "description": "The bundler for TitanPl servers.",
+  "keywords": [
+    "bundler",
+    "titanpl",
+    "titan",
+    "ezetgalaxy"
+  ],
+  "license": "ISC",
+  "author": "ezetgalaxy",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/ts/titan/builder.js

@@ -0,0 +1,121 @@
+import { bundle } from "./bundle.js";
+import fs from "fs";
+import path from "path";
+
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+
+const routes = {};
+const dynamicRoutes = {};
+const actionMap = {};
+
+function addRoute(method, route) {
+    const key = `${method.toUpperCase()}:${route}`;
+
+
+    return {
+        reply(value) {
+            routes[key] = {
+                type: typeof value === "object" ? "json" : "text",
+                value
+            };
+        },
+
+        action(name) {
+            if (route.includes(":")) {
+                if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
+                dynamicRoutes[method].push({
+                    method: method.toUpperCase(),
+                    pattern: route,
+                    action: name
+                });
+            } else {
+                routes[key] = {
+                    type: "action",
+                    value: name
+                };
+                actionMap[key] = name;
+            }
+        }
+    };
+}
+
+/**
+ * @typedef {Object} RouteHandler
+ * @property {(value: any) => void} reply - Send a direct response
+ * @property {(name: string) => void} action - Bind to a server-side action
+ */
+
+/**
+ * Titan App Builder
+ */
+const t = {
+    /**
+     * Define a GET route
+     * @param {string} route 
+     * @returns {RouteHandler}
+     */
+    get(route) {
+        return addRoute("GET", route);
+    },
+
+    /**
+     * Define a POST route
+     * @param {string} route 
+     * @returns {RouteHandler}
+     */
+    post(route) {
+        return addRoute("POST", route);
+    },
+
+    log(module, msg) {
+        console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
+    },
+
+    /**
+     * Start the Titan Server
+     * @param {number} [port=3000] 
+     * @param {string} [msg=""] 
+     */
+    async start(port = 3000, msg = "") {
+        try {
+            console.log(cyan("[Titan] Preparing runtime..."));
+            await bundle();
+
+            const base = path.join(process.cwd(), "server");
+            if (!fs.existsSync(base)) {
+                fs.mkdirSync(base, { recursive: true });
+            }
+
+            const routesPath = path.join(base, "routes.json");
+            const actionMapPath = path.join(base, "action_map.json");
+
+            fs.writeFileSync(
+                routesPath,
+                JSON.stringify(
+                    {
+                        __config: { port },
+                        routes,
+                        __dynamic_routes: Object.values(dynamicRoutes).flat()
+                    },
+                    null,
+                    2
+                )
+            );
+
+            fs.writeFileSync(
+                actionMapPath,
+                JSON.stringify(actionMap, null, 2)
+            );
+
+            console.log(green("✔ Titan metadata written successfully"));
+            if (msg) console.log(cyan(msg));
+
+        } catch (e) {
+            console.error(`\x1b[31m[Titan] Build Error: ${e.message}\x1b[0m`);
+            process.exit(1);
+        }
+    }
+};
+
+export default t;

package/ts/titan/bundle.js

@@ -0,0 +1,123 @@
+import fs from "fs";
+import path from "path";
+import esbuild from "esbuild";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+
+/* ------------------------------------------------------------------
+   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",
+  "node:process": "@titanpl/node/process",
+
+  "events": "@titanpl/node/events",
+  "node:events": "@titanpl/node/events",
+
+  "util": "@titanpl/node/util",
+  "node:util": "@titanpl/node/util"
+};
+
+/* ------------------------------------------------------------------
+   Titan Node Compatibility Plugin
+------------------------------------------------------------------ */
+
+const titanNodeCompatPlugin = {
+  name: "titan-node-compat",
+  setup(build) {
+    build.onResolve({ filter: /.*/ }, args => {
+      const replacement = NODE_BUILTIN_MAP[args.path];
+      if (!replacement) return;
+
+      // MUST return absolute path for esbuild
+      const resolved = require.resolve(replacement);
+      return { path: resolved };
+    });
+  }
+};
+
+/* ------------------------------------------------------------------
+   Main Bundle Entry
+------------------------------------------------------------------ */
+
+export async function bundle() {
+  const root = process.cwd();
+  const actionsDir = path.join(root, "app", "actions");
+  const outDir = path.join(root, "server", "src", "actions");
+
+  await bundleJs(actionsDir, outDir);
+}
+
+/* ------------------------------------------------------------------
+   Bundle JS Actions
+------------------------------------------------------------------ */
+
+async function bundleJs(actionsDir, outDir) {
+  if (!fs.existsSync(actionsDir)) return;
+
+  fs.mkdirSync(outDir, { recursive: true });
+
+  // Clean old bundles
+  const oldFiles = fs.readdirSync(outDir);
+  for (const file of oldFiles) {
+    fs.unlinkSync(path.join(outDir, file));
+  }
+
+  const files = fs
+    .readdirSync(actionsDir)
+    .filter(f => f.endsWith(".js") || f.endsWith(".ts"));
+
+  if (files.length === 0) return;
+
+  for (const file of files) {
+    const actionName = path.basename(file, path.extname(file));
+    const entry = path.join(actionsDir, file);
+    const outfile = path.join(outDir, actionName + ".jsbundle");
+
+    await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      format: "iife",
+      globalName: "__titan_exports",
+      platform: "node",          // important for npm libs
+      target: "es2020",
+      logLevel: "silent",
+      plugins: [titanNodeCompatPlugin],
+
+      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);
+})();
+`
+      }
+    });
+  }
+}