titanpl 2.0.1 → 2.0.3

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

@@ -1,164 +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__');
-    }
-  }
-}
+/**
+ * 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

@@ -38,33 +38,53 @@ function getEngineBinaryPath(root) {
     // 1. Monorepo search (dev environment)
     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;
+        const potentialRelease = path.join(current, 'engine', 'target', 'release', binName);
+        if (fs.existsSync(potentialRelease)) return potentialRelease;
+        const potentialDebug = path.join(current, 'engine', 'target', 'debug', binName);
+        if (fs.existsSync(potentialDebug)) return potentialDebug;
+
+        // Check sibling monorepo folder for test-apps
+        const siblingRelease = path.join(current, 'titanpl', 'engine', 'target', 'release', binName);
+        if (fs.existsSync(siblingRelease)) return siblingRelease;
+        const siblingDebug = path.join(current, 'titanpl', 'engine', 'target', 'debug', binName);
+        if (fs.existsSync(siblingDebug)) return siblingDebug;
+        const siblingPkg = path.join(current, 'titanpl', 'packages', pkgName.replace('@titanpl/', ''), 'bin', binName);
+        if (fs.existsSync(siblingPkg)) return siblingPkg;
+
         current = path.dirname(current);
     }
 
     // 2. Search relative to @titanpl/cli (where optionalDependencies are installed)
-    //    This is the primary path for globally-installed CLI users.
     try {
-        const require = createRequire(import.meta.url);
-        const cliPkgPath = require.resolve('@titanpl/cli/package.json');
+        const req = createRequire(import.meta.url);
+        const cliPkgPath = req.resolve('@titanpl/cli/package.json');
         const cliDir = path.dirname(cliPkgPath);
-        // Check cli's own node_modules (global install sibling)
         const cliNodeModulesBin = path.join(cliDir, 'node_modules', pkgName, 'bin', binName);
         if (fs.existsSync(cliNodeModulesBin)) return cliNodeModulesBin;
-        // Check parent node_modules (hoisted global install)
-        const parentNodeModulesBin = path.join(path.dirname(cliDir), pkgName, 'bin', binName);
+
+        const nodeModulesDir = path.dirname(path.dirname(cliDir));
+        const parentNodeModulesBin = path.join(nodeModulesDir, pkgName, 'bin', binName);
         if (fs.existsSync(parentNodeModulesBin)) return parentNodeModulesBin;
     } catch (e) { }
 
-    // 3. Search in the project's own node_modules
+    // 3. Search in the project's own node_modules directly
     try {
-        const require = createRequire(import.meta.url);
-        const pkgPath = require.resolve(`${pkgName}/package.json`);
+        const req = createRequire(import.meta.url);
+        const pkgPath = req.resolve(`${pkgName}/package.json`);
         const binPath = path.join(path.dirname(pkgPath), 'bin', binName);
         if (fs.existsSync(binPath)) return binPath;
     } catch (e) { }
 
+    // Walk upwards from current dir searching for node_modules/@titanpl/engine-...
+    let searchDir = process.cwd();
+    for (let i = 0; i < 5; i++) {
+        const nmBin = path.join(searchDir, 'node_modules', pkgName, 'bin', binName);
+        if (fs.existsSync(nmBin)) return nmBin;
+        const parent = path.dirname(searchDir);
+        if (parent === searchDir) break;
+        searchDir = parent;
+    }
+
     // 4. Fallback: check common global npm paths
     const globalSearchRoots = [
         process.env.npm_config_prefix,
@@ -76,8 +96,16 @@ function getEngineBinaryPath(root) {
     for (const gRoot of globalSearchRoots) {
         const gBin = path.join(gRoot, 'node_modules', pkgName, 'bin', binName);
         if (fs.existsSync(gBin)) return gBin;
+        const libNodeModulesBin = path.join(gRoot, 'lib', 'node_modules', pkgName, 'bin', binName);
+        if (fs.existsSync(libNodeModulesBin)) return libNodeModulesBin;
     }
 
+    try {
+        const globalModules = execSync('npm root -g').toString().trim();
+        const globalBin = path.join(globalModules, pkgName, 'bin', binName);
+        if (fs.existsSync(globalBin)) return globalBin;
+    } catch (e) { }
+
     return null;
 }
 
@@ -87,22 +115,28 @@ async function killServer() {
     if (!serverProcess) return;
 
     return new Promise((resolve) => {
-        const onExit = () => {
+        if (serverProcess.killed || serverProcess.exitCode !== null) {
             serverProcess = null;
             resolve();
+            return;
+        }
+
+        let isDone = false;
+        const onExit = () => {
+            if (isDone) return;
+            isDone = true;
+            serverProcess = null;
+            setTimeout(resolve, 300); // Grace period for OS socket release
         };
 
         serverProcess.on('exit', onExit);
+        serverProcess.on('error', onExit);
 
-        if (os.platform() === 'win32') {
-            try {
-                execSync(`taskkill /pid ${serverProcess.pid} /f /t`, { stdio: 'ignore' });
-            } catch (e) { }
-        } else {
+        try {
             serverProcess.kill('SIGKILL');
-        }
+        } catch (e) { }
 
-        setTimeout(onExit, 500);
+        setTimeout(onExit, 800); // Fallback
     });
 }