@reliverse/rempts 1.7.24 → 1.7.26

package/bin/components/launcher/launcher-mod.js

@@ -307,8 +307,15 @@ export async function showUsage(command, parserOptions = {}) {
   }
 }
 export async function runMain(command, parserOptions = {}) {
-  if (typeof command.onLauncherInit === "function")
-    await command.onLauncherInit();
+  if (typeof command.onLauncherInit === "function") {
+    try {
+      await command.onLauncherInit();
+    } catch (err) {
+      relinka("error", "Error in onLauncherInit:", err);
+      if (parserOptions.autoExit !== false) process.exit(1);
+      throw err;
+    }
+  }
   try {
     if (!parserOptions.fileBasedCmds && !command.commands) {
       let callerDir = process.cwd();
@@ -327,26 +334,17 @@ export async function runMain(command, parserOptions = {}) {
         }
         if (callerFile) {
           callerDir = path.dirname(callerFile);
-          const rel = path.relative(process.cwd(), callerFile);
-          if (/app[/][^/]+[/]cmd\.(ts|js)$/.test(rel)) {
-            relinka(
-              "error",
-              `runMain() should not be called from a file-based subcommand: ${rel}
+          if (parserOptions.fileBasedCmds?.enable) {
+            const rel = path.relative(process.cwd(), callerFile);
+            if (/app[/][^/]+[/]cmd\.(ts|js)$/.test(rel)) {
+              relinka(
+                "error",
+                `runMain() should not be called from a file-based subcommand: ${rel}
 This can cause recursion or unexpected behavior.
 Move your runMain() call to your main CLI entry file.`
-            );
-            process.exit(1);
-          }
-          const mainEntry = process.argv[1] ? path.resolve(process.argv[1]) : void 0;
-          if (mainEntry && path.resolve(callerFile) !== mainEntry) {
-            relinka(
-              "error",
-              `runMain() should only be called from your main CLI entry file.
-Detected: ${callerFile}
-Main entry: ${mainEntry}
-This can cause recursion or unexpected behavior.`
-            );
-            process.exit(1);
+              );
+              process.exit(1);
+            }
           }
         }
       } catch (_e) {

package/bin/components/launcher/run-command.js

@@ -8,58 +8,71 @@ const jiti = createJiti(import.meta.url, {
   fsCache: true,
   sourceMaps: true
 });
+const COMMAND_EXTENSIONS = [".ts", ".js"];
+const COMMAND_FILENAMES = ["cmd.ts", "cmd.js"];
+const getCallerDirectory = () => {
+  const stack = new Error().stack?.split("\n") ?? [];
+  for (const line of stack) {
+    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
+    if (match?.[1] && !match[1].includes("run-command")) {
+      return dirname(match[1]);
+    }
+  }
+  return process.cwd();
+};
+const tryLoadCommand = async (path) => {
+  if (!await fs.pathExists(path)) return null;
+  try {
+    relinka("verbose", `Attempting to load command from: ${path}`);
+    const cmd = await jiti.import(path, { default: true });
+    relinka("verbose", `Successfully loaded command from: ${path}`);
+    return cmd;
+  } catch {
+    relinka("verbose", `Failed to load ${path} as a command file`);
+    return null;
+  }
+};
+const generateCandidatePaths = async (resolvedPath) => {
+  if (!await fs.pathExists(resolvedPath)) {
+    return COMMAND_EXTENSIONS.map((ext) => `${resolvedPath}${ext}`);
+  }
+  if (await fs.isDirectory(resolvedPath)) {
+    return COMMAND_FILENAMES.map((filename) => resolve(resolvedPath, filename));
+  }
+  return [resolvedPath];
+};
+const createCommandNotFoundError = (cmdPath, searchedPaths) => new Error(
+  `No command file found for "${cmdPath}". Expected to find either:
+  - A valid command file at the specified path
+  - A directory containing cmd.ts or cmd.js  
+  - A file path that can be resolved with .ts or .js extension
+Searched paths: ${searchedPaths.join(", ")}
+Please ensure one of these exists and exports a default command.`
+);
+const createLoadError = (cmdPath, originalError) => new Error(
+  `Failed to load command from "${cmdPath}"
+For developers: Ensure the command file:
+  - Exists and is accessible
+  - Exports a default command (e.g., export default defineCommand({...}))
+  - Is a valid TypeScript/JavaScript module
+Original error: ${originalError instanceof Error ? originalError.message : String(originalError)}`
+);
 export async function loadCommand(cmdPath) {
   try {
-    const err = new Error();
-    const stack = err.stack?.split("\n");
-    let callerFile;
-    if (stack) {
-      for (const line of stack) {
-        const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-        if (match?.[1] && !match[1].includes("run-command")) {
-          callerFile = match[1];
-          break;
-        }
-      }
-    }
-    const callerDir = callerFile ? dirname(callerFile) : process.cwd();
+    const callerDir = getCallerDirectory();
     const normalizedPath = cmdPath.replace(/^\.\//, "");
     const resolvedPath = resolve(callerDir, normalizedPath);
-    if (!resolvedPath.endsWith("cmd.ts") && !resolvedPath.endsWith("cmd.js")) {
-      const possiblePaths = [
-        resolve(resolvedPath, "cmd.ts"),
-        resolve(resolvedPath, "cmd.js")
-      ];
-      for (const path of possiblePaths) {
-        if (await fs.pathExists(path)) {
-          relinka("verbose", `Loading command from: ${path}`);
-          const cmd2 = await jiti.import(path, { default: true });
-          relinka("verbose", `Successfully loaded command from: ${path}`);
-          return cmd2;
-        }
-      }
-      throw new Error(
-        `No command file found in ${resolvedPath}. Expected to find either:
-  - ${possiblePaths[0]}
-  - ${possiblePaths[1]}
-Please ensure one of these files exists and exports a default command.`
-      );
+    const candidatePaths = await generateCandidatePaths(resolvedPath);
+    for (const path of candidatePaths) {
+      const command = await tryLoadCommand(path);
+      if (command) return command;
     }
-    relinka("verbose", `Loading command from: ${resolvedPath}`);
-    const cmd = await jiti.import(resolvedPath, { default: true });
-    relinka("verbose", `Successfully loaded command from: ${resolvedPath}`);
-    return cmd;
+    throw createCommandNotFoundError(cmdPath, candidatePaths);
   } catch (error) {
     if (error instanceof Error && error.message.includes("No command file found")) {
       throw error;
     }
     relinka("error", `Failed to load command from ${cmdPath}:`, error);
-    throw new Error(
-      `Failed to load command from ${cmdPath}:
-  - Make sure the file exists and is accessible
-  - Ensure the file exports a default command
-  - Check that the file is a valid TypeScript/JavaScript module
-Original error: ${error instanceof Error ? error.message : String(error)}`
-    );
+    throw createLoadError(cmdPath, error);
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
     "@figliolia/chalk-animation": "^1.0.4",
-    "@reliverse/pathkit": "^1.2.1",
+    "@reliverse/pathkit": "^1.3.3",
     "@reliverse/reliarg": "^1.0.3",
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relifso": "^1.4.5",
@@ -29,7 +29,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.24",
+  "version": "1.7.26",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",