@orion-js/core 4.0.6 → 4.0.8

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk14 from "chalk";
+import chalk16 from "chalk";
 import { Command } from "commander";
 
 // src/helpers/execute.ts
@@ -34,7 +34,7 @@ async function create_default({ name, kit }) {
 }
 
 // src/dev/runner/index.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 
 // src/helpers/writeFile.ts
 import fs2 from "fs";
@@ -51,34 +51,30 @@ var ensureDirectory = (filePath) => {
 var ensureDirectory_default = ensureDirectory;
 
 // src/helpers/writeFile.ts
-async function writeFile_default(path7, content) {
-  ensureDirectory_default(path7);
-  fs2.writeFileSync(path7, content);
+async function writeFile_default(path6, content) {
+  ensureDirectory_default(path6);
+  fs2.writeFileSync(path6, content);
 }
 
 // src/dev/runner/startProcess.ts
 import { spawn } from "child_process";
 
 // src/dev/runner/getArgs.ts
-function getArgs(options, command) {
-  let startCommand = process.env.START_COMMAND || "tsx";
+function getArgs(_options, command) {
+  const startCommand = "tsx";
   const args = [];
-  if (process.env.START_COMMAND) {
-    const [first, ...otherArgs] = process.env.START_COMMAND.split(" ");
-    startCommand = first;
-    args.push(...otherArgs);
-    console.log(`Using custom command: ${[startCommand, ...args].join(" ")}`);
-  } else if (options.shell) {
-    args.push("--inspect");
-  }
+  args.push("watch", "--clear-screen=false");
   args.push(...command.args);
   args.push("./app/index.ts");
   return { startCommand, args };
 }
 
 // src/dev/runner/startProcess.ts
+import chalk from "chalk";
 function startProcess(options, command) {
   const { startCommand, args } = getArgs(options, command);
+  console.log(chalk.bold(`=> Starting app with command: ${startCommand} ${args.join(" ")}...
+`));
   return spawn(startCommand, args, {
     env: {
       ORION_DEV: "local",
@@ -94,15 +90,14 @@ function startProcess(options, command) {
 function getRunner(options, command) {
   let appProcess = null;
   if (options.clean) {
-    console.log(chalk.bold("=> Cleaning directory...\n"));
+    console.log(chalk2.bold("=> Cleaning directory...\n"));
   }
-  const start = () => {
-    console.log(chalk.bold("=> Starting app...\n"));
+  const startApp = () => {
     appProcess = startProcess(options, command);
     appProcess.on("exit", (code, signal) => {
       if (!code || code === 143 || code === 0 || signal === "SIGTERM" || signal === "SIGINT") {
       } else {
-        console.log(chalk.bold(`=> Error running app. Exit code: ${code}`));
+        console.log(chalk2.bold(`=> Error running app. Exit code: ${code}`));
       }
     });
     writeFile_default(".orion/process", `${appProcess.pid}`);
@@ -110,15 +105,24 @@ function getRunner(options, command) {
   const stop = () => {
     if (appProcess) {
       appProcess.kill();
+      appProcess = null;
     }
   };
   const restart = () => {
+    console.log(chalk2.bold("=> Restarting app...\n"));
     stop();
-    start();
+    startApp();
+  };
+  const start = () => {
+    if (appProcess) {
+    } else {
+      startApp();
+    }
   };
   return {
     restart,
-    stop
+    stop,
+    start
   };
 }
 
@@ -211,21 +215,21 @@ function reportDiagnostic(diagnostic) {
 }
 
 // src/dev/watchAndCompile/getHost.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 function getHost(runner) {
   const reportWatchStatusChanged = (diagnostic) => {
     if (diagnostic.category !== 3) return;
     if (diagnostic.code === 6032 || diagnostic.code === 6031) {
       runner.stop();
     }
-    console.log(chalk2.bold(`=> ${diagnostic.messageText}`));
+    console.log(chalk3.bold(`=> ${diagnostic.messageText}`));
     if (diagnostic.code === 6194) {
       if (/^Found .+ errors?/.test(diagnostic.messageText.toString())) {
         if (!diagnostic.messageText.toString().includes("Found 0 errors.")) {
           return;
         }
       }
-      runner.restart();
+      runner.start();
     }
   };
   const configPath = getConfigPath();
@@ -241,41 +245,17 @@ function getHost(runner) {
   return host;
 }
 
-// src/dev/watchAndCompile/watchDeletes.ts
-import fs5 from "fs";
-import path3 from "path";
-import chokidar from "chokidar";
-async function watchDeletes() {
-  const projectPath = path3.resolve("./app");
-  const watcher = chokidar.watch(projectPath, {
-    ignoreInitial: true
-  });
-  watcher.on("unlink", async (filepath) => {
-    if (!filepath.endsWith(".ts")) return;
-    const relative = path3.relative(process.cwd(), filepath);
-    const atBuildPath = path3.resolve(".orion/build", relative.replace(/.ts$/, ""));
-    try {
-      fs5.unlinkSync(`${atBuildPath}.js`);
-      fs5.unlinkSync(`${atBuildPath}.d.ts`);
-    } catch (error) {
-      console.log(
-        `Error cleaning ${atBuildPath}. Restar project is suggested. Error: ${error.message}`
-      );
-    }
-  });
-}
-
 // src/dev/watchAndCompile/writeEnvFile.ts
 import { writeDtsFileFromConfigFile } from "@orion-js/env";
-import chalk3 from "chalk";
-import chokidar2 from "chokidar";
+import chalk4 from "chalk";
+import chokidar from "chokidar";
 var envFilePath = process.env.ORION_ENV_FILE_PATH;
 var dtsFilePath = "./app/env.d.ts";
 var watchEnvFile = async (runner) => {
   if (!envFilePath) return;
   writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
-  chokidar2.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
-    console.log(chalk3.bold("=> Environment file changed. Restarting..."));
+  chokidar.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
+    console.log(chalk4.bold("=> Environment file changed. Restarting..."));
     writeDtsFileFromConfigFile(envFilePath, dtsFilePath);
     runner.restart();
   });
@@ -286,15 +266,14 @@ async function watchAndCompile(runner) {
   await cleanDirectory();
   const host = getHost(runner);
   ts4.createWatchProgram(host);
-  watchDeletes();
   watchEnvFile(runner);
 }
 
 // src/dev/copyCursorRule/index.ts
-import fs6 from "fs/promises";
+import fs5 from "fs/promises";
 import https from "https";
-import path4 from "path";
-import chalk4 from "chalk";
+import path3 from "path";
+import chalk5 from "chalk";
 var rules = [
   "orionjs.mdx",
   "orionjs-component.mdx",
@@ -327,55 +306,55 @@ var downloadFile = (url) => {
 async function copyCursorRule() {
   const baseUrl = "https://raw.githubusercontent.com/orionjs/orionjs/refs/heads/master/mdc";
   try {
-    const targetDir = path4.join(process.cwd(), ".cursor", "rules");
-    await fs6.mkdir(targetDir, { recursive: true });
+    const targetDir = path3.join(process.cwd(), ".cursor", "rules");
+    await fs5.mkdir(targetDir, { recursive: true });
     await Promise.all(
       rules.map(async (rule) => {
         const targetFileName = rule.replace(".mdx", ".mdc");
-        const targetFile = path4.join(targetDir, targetFileName);
+        const targetFile = path3.join(targetDir, targetFileName);
         const sourceUrl = `${baseUrl}/${rule}`;
         const content = await downloadFile(sourceUrl);
-        await fs6.writeFile(targetFile, content, "utf8");
-        console.log(chalk4.bold(`=> \u2728 Successfully downloaded ${chalk4.cyan(targetFileName)}`));
+        await fs5.writeFile(targetFile, content, "utf8");
+        console.log(chalk5.bold(`=> \u2728 Successfully downloaded ${chalk5.cyan(targetFileName)}`));
       })
     );
-    console.log(chalk4.bold("=> \u2728 All rule files have been successfully copied"));
+    console.log(chalk5.bold("=> \u2728 All rule files have been successfully copied"));
   } catch (error) {
-    console.error(chalk4.red(`Error copying rule files: ${error.message}`));
+    console.error(chalk5.red(`Error copying rule files: ${error.message}`));
   }
 }
 
 // src/dev/copyMCP/index.ts
-import fs8 from "fs/promises";
-import path6 from "path";
-import chalk6 from "chalk";
+import fs7 from "fs/promises";
+import path5 from "path";
+import chalk7 from "chalk";
 
 // src/dev/copyMCP/consts.ts
 var MCP_VERSION = "v4";
 var VERSION_FILE = "version.txt";
 
 // src/dev/copyMCP/isValidMCPRepo.ts
-import fs7 from "fs/promises";
-import path5 from "path";
-import chalk5 from "chalk";
+import fs6 from "fs/promises";
+import path4 from "path";
+import chalk6 from "chalk";
 async function isValidMCPRepository(directoryPath) {
   try {
-    const stats = await fs7.stat(directoryPath);
+    const stats = await fs6.stat(directoryPath);
     if (!stats.isDirectory()) return false;
     const expectedFiles = ["settings.js", "package.json"];
     for (const file of expectedFiles) {
       try {
-        await fs7.access(path5.join(directoryPath, file));
+        await fs6.access(path4.join(directoryPath, file));
       } catch {
         return false;
       }
     }
     try {
-      const versionPath = path5.join(directoryPath, VERSION_FILE);
-      const versionContent = await fs7.readFile(versionPath, "utf-8");
+      const versionPath = path4.join(directoryPath, VERSION_FILE);
+      const versionContent = await fs6.readFile(versionPath, "utf-8");
       if (versionContent.trim() !== MCP_VERSION) {
         console.log(
-          chalk5.yellow(
+          chalk6.yellow(
             `=> \u2728 MCP version mismatch: installed=${versionContent.trim()}, required=${MCP_VERSION}`
           )
         );
@@ -393,71 +372,71 @@ async function isValidMCPRepository(directoryPath) {
 // src/dev/copyMCP/index.ts
 async function copyMCP() {
   const repoUrl = "https://github.com/orionjs/mcp-docs";
-  const targetDir = path6.join(process.cwd(), ".orion", "mcp");
+  const targetDir = path5.join(process.cwd(), ".orion", "mcp");
   try {
-    await fs8.mkdir(path6.join(process.cwd(), ".orion"), { recursive: true });
+    await fs7.mkdir(path5.join(process.cwd(), ".orion"), { recursive: true });
     if (await isValidMCPRepository(targetDir)) {
-      console.log(chalk6.bold("=> \u2728 MCP documentation already installed"));
+      console.log(chalk7.bold("=> \u2728 MCP documentation already installed"));
       return;
     }
     try {
-      const stats = await fs8.stat(targetDir);
+      const stats = await fs7.stat(targetDir);
       if (stats.isDirectory()) {
-        await fs8.rm(targetDir, { recursive: true, force: true });
+        await fs7.rm(targetDir, { recursive: true, force: true });
         console.log(
-          chalk6.bold(
+          chalk7.bold(
             "=> \u2728 Removed existing .orion/mcp directory (invalid, incomplete, or outdated)"
           )
         );
       }
     } catch (_) {
     }
-    console.log(chalk6.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
+    console.log(chalk7.bold(`=> \u2728 Downloading MCP documentation ${MCP_VERSION}...`));
     await execute_default(`git clone ${repoUrl} ${targetDir}`);
-    await execute_default(`rm -rf ${path6.join(targetDir, ".git")}`);
-    await fs8.writeFile(path6.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
+    await execute_default(`rm -rf ${path5.join(targetDir, ".git")}`);
+    await fs7.writeFile(path5.join(targetDir, VERSION_FILE), MCP_VERSION, "utf-8");
     console.log(
-      chalk6.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
+      chalk7.bold(`=> \u2728 Successfully downloaded MCP documentation v${MCP_VERSION} to .orion/mcp`)
     );
-    console.log(chalk6.bold("=> \u2728 Installing MCP dependencies..."));
+    console.log(chalk7.bold("=> \u2728 Installing MCP dependencies..."));
     await execute_default(`cd ${targetDir} && npm install`);
-    console.log(chalk6.bold("=> \u2728 Successfully installed MCP dependencies"));
-    const relativePath = path6.relative(process.cwd(), targetDir);
+    console.log(chalk7.bold("=> \u2728 Successfully installed MCP dependencies"));
+    const relativePath = path5.relative(process.cwd(), targetDir);
     console.log(relativePath);
     const mcpServerConfig = {
       mcpServers: {
         "Orionjs documentation search": {
           command: "node",
-          args: [`./${path6.join(relativePath, "src", "index.js")}`]
+          args: [`./${path5.join(relativePath, "src", "index.js")}`]
         }
       }
     };
-    const configPath = path6.join(process.cwd(), ".cursor", "mcp.json");
+    const configPath = path5.join(process.cwd(), ".cursor", "mcp.json");
     try {
-      const existingConfig = await fs8.readFile(configPath, "utf-8");
+      const existingConfig = await fs7.readFile(configPath, "utf-8");
       const parsedConfig = JSON.parse(existingConfig);
       parsedConfig.mcpServers = {
         ...parsedConfig.mcpServers,
         ...mcpServerConfig.mcpServers
       };
-      await fs8.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
-      console.log(chalk6.bold("=> \u2728 Updated MCP server configuration in .cursor/mcp.json"));
+      await fs7.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
+      console.log(chalk7.bold("=> \u2728 Updated MCP server configuration in .cursor/mcp.json"));
     } catch (_) {
-      await fs8.mkdir(path6.dirname(configPath), { recursive: true });
-      await fs8.writeFile(configPath, JSON.stringify(mcpServerConfig, null, 2), "utf-8");
-      console.log(chalk6.bold("=> \u2728 Created new MCP server configuration in .cursor/mcp.json"));
+      await fs7.mkdir(path5.dirname(configPath), { recursive: true });
+      await fs7.writeFile(configPath, JSON.stringify(mcpServerConfig, null, 2), "utf-8");
+      console.log(chalk7.bold("=> \u2728 Created new MCP server configuration in .cursor/mcp.json"));
     }
   } catch (error) {
-    console.error(chalk6.red("=> \u2728 Error copying MCP documentation:"), error);
+    console.error(chalk7.red("=> \u2728 Error copying MCP documentation:"), error);
     throw error;
   }
 }
 
 // src/dev/index.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 async function dev_default(options, command) {
-  console.log(chalk7.bold(`
-Orionjs App ${chalk7.green(chalk7.bold("V4"))} Dev mode 
+  console.log(chalk8.bold(`
+Orionjs App ${chalk8.green(chalk8.bold("V4"))} Dev mode 
 `));
   if (!options.omitCursorRule) {
     await copyCursorRule().catch(console.error);
@@ -466,20 +445,21 @@ Orionjs App ${chalk7.green(chalk7.bold("V4"))} Dev mode
     await copyMCP().catch(console.error);
   }
   if (!options.omitMcpServer && !options.omitCursorRule) {
-    console.log(chalk7.bold("=> \u2728 Orionjs AI is ready\n"));
+    console.log(chalk8.bold("=> \u2728 Orionjs AI is ready\n"));
   }
   const runner = getRunner(options, command);
   watchAndCompile(runner);
 }
 
 // src/prod/index.ts
-import chalk9 from "chalk";
+import chalk12 from "chalk";
 
 // src/prod/runProd.ts
 import { spawn as spawn2 } from "child_process";
-function runProd(command) {
-  const args = [...command.args, "./app/index.ts"];
-  spawn2("tsx", args, {
+function runProd(options, command) {
+  const indexPath = `${options.path}/index.js`;
+  const args = ["--import=tsx", ...command.args, indexPath];
+  spawn2("node", args, {
     env: {
       NODE_ENV: "production",
       ...process.env
@@ -492,46 +472,89 @@ function runProd(command) {
   });
 }
 
-// src/prod/checkTs.ts
-import chalk8 from "chalk";
-import { execSync } from "child_process";
-function checkTs() {
+// src/build/index.ts
+import chalk11 from "chalk";
+
+// src/build/build.ts
+import chalk9 from "chalk";
+import * as esbuild from "esbuild";
+async function build2(options) {
+  const { output } = options;
+  console.log(`Building with esbuild to ${output}`);
+  await esbuild.build({
+    entryPoints: ["./app/index.ts"],
+    tsconfig: "./tsconfig.json",
+    format: "esm",
+    platform: "node",
+    outdir: output,
+    bundle: true,
+    target: "node22",
+    sourcemap: true,
+    allowOverwrite: true,
+    minify: true,
+    packages: "external"
+  });
+  console.log(chalk9.green.bold("Build successful"));
+}
+
+// src/build/checkTs.ts
+import chalk10 from "chalk";
+import { exec as exec2 } from "child_process";
+import { promisify } from "util";
+var execPromise = promisify(exec2);
+async function checkTs() {
   try {
-    execSync("tsc --noEmit", {
+    console.log("Checking TypeScript...");
+    await execPromise("tsc --noEmit", {
       cwd: process.cwd(),
       env: {
         ...process.env
       },
       gid: process.getgid(),
-      uid: process.getuid(),
-      stdio: "inherit"
+      uid: process.getuid()
     });
-  } catch {
-    console.log(chalk8.red.bold("TypeScript compilation failed"));
+    console.log(chalk10.green.bold("TypeScript check passed"));
+  } catch (error) {
+    console.log(chalk10.red.bold("TypeScript compilation failed"));
+    console.log(error.stderr || error.stdout || error.message);
     process.exit(1);
   }
 }
 
+// src/build/index.ts
+async function build_default(options) {
+  console.log(chalk11.bold(`Building Orionjs App ${chalk11.green(chalk11.bold("V4"))}...`));
+  if (!options.output) {
+    options.output = "./build";
+  }
+  await cleanDirectory(options.output);
+  await Promise.all([checkTs(), build2(options)]);
+  console.log(chalk11.bold("Build completed"));
+}
+
 // src/prod/index.ts
-async function prod_default(_, command) {
-  console.log(chalk9.bold(`
-Orionjs App ${chalk9.green(chalk9.bold("V4"))} Prod mode
+async function prod_default(options, command) {
+  console.log(chalk12.bold(`
+Orionjs App ${chalk12.green(chalk12.bold("V4"))} Prod mode
 `));
-  checkTs();
-  runProd(command);
+  if (!options.path) {
+    await build_default({ output: "./build" });
+    options.path = "./build";
+  }
+  runProd(options, command);
 }
 
 // src/handleErrors.ts
-import chalk10 from "chalk";
+import chalk13 from "chalk";
 process.on("unhandledRejection", (error) => {
   if (error.codeFrame) {
-    console.error(chalk10.red(error.message));
+    console.error(chalk13.red(error.message));
     console.log(error.codeFrame);
   } else {
-    console.error(chalk10.red(error.message), chalk10.red("Unhandled promise rejection"));
+    console.error(chalk13.red(error.message), chalk13.red("Unhandled promise rejection"));
   }
 }).on("uncaughtException", (error) => {
-  console.error(chalk10.red(error.message));
+  console.error(chalk13.red(error.message));
   process.exit(1);
 });
 
@@ -542,14 +565,14 @@ var version_default = "3.0";
 import "dotenv/config";
 
 // src/check/index.ts
-import chalk12 from "chalk";
+import chalk15 from "chalk";
 
 // src/check/checkTs.ts
-import chalk11 from "chalk";
-import { execSync as execSync2 } from "child_process";
+import chalk14 from "chalk";
+import { execSync } from "child_process";
 function checkTs2() {
   try {
-    execSync2("tsc --noEmit", {
+    execSync("tsc --noEmit", {
       cwd: process.cwd(),
       env: {
         ...process.env
@@ -559,54 +582,18 @@ function checkTs2() {
       stdio: "inherit"
     });
   } catch {
-    console.log(chalk11.red.bold("TypeScript compilation failed"));
+    console.log(chalk14.red.bold("TypeScript compilation failed"));
     process.exit(1);
   }
 }
 
 // src/check/index.ts
 async function check_default() {
-  console.log(chalk12.bold(`Orionjs App ${chalk12.green(chalk12.bold("V4"))}
+  console.log(chalk15.bold(`Orionjs App ${chalk15.green(chalk15.bold("V4"))}
 `));
   console.log("Checking typescript...");
   checkTs2();
-  console.log(chalk12.bold.green("Check passed\n"));
-}
-
-// src/build/index.ts
-import chalk13 from "chalk";
-
-// src/build/build.ts
-import { typecheckPlugin } from "@jgoz/esbuild-plugin-typecheck";
-import * as esbuild from "esbuild";
-async function build2(options) {
-  const { output } = options;
-  console.log(`Building with esbuild to ${output}`);
-  await esbuild.build({
-    entryPoints: ["./app/index.ts"],
-    tsconfig: "./tsconfig.json",
-    format: "esm",
-    platform: "node",
-    outdir: output,
-    bundle: true,
-    target: "node22",
-    sourcemap: true,
-    allowOverwrite: true,
-    minify: true,
-    packages: "external",
-    plugins: [typecheckPlugin()]
-  });
-}
-
-// src/build/index.ts
-async function build_default(options) {
-  console.log(chalk13.bold(`Building Orionjs App ${chalk13.green(chalk13.bold("V4"))}...`));
-  if (!options.output) {
-    options.output = "./build";
-  }
-  await cleanDirectory(options.output);
-  await build2(options);
-  console.log(chalk13.bold("Build successful"));
+  console.log(chalk15.bold.green("Check passed\n"));
 }
 
 // src/index.ts
@@ -615,13 +602,16 @@ var run = (action) => async (...args) => {
   try {
     await action(...args);
   } catch (e) {
-    console.error(chalk14.red(`Error: ${e.message}`));
+    console.error(chalk16.red(`Error: ${e.message}`));
   }
 };
-program.command("dev").description("Run the Orionjs app in development mode").option("--shell", "Opens a shell in Chrome developer tools").option("--omit-cursor-rule", "Omit the creation of the Orionjs Cursor rule").option("--omit-mcp-server", "Omit the creation of the Orionjs MCP server").allowUnknownOption().action(run(dev_default));
+program.command("dev").description("Run the Orionjs app in development mode").option("--omit-cursor-rule", "Omit the creation of the Orionjs Cursor rule").option("--omit-mcp-server", "Omit the creation of the Orionjs MCP server").allowUnknownOption().action(run(dev_default));
 program.command("check").description("Runs a typescript check").action(run(check_default));
 program.command("build").description("Build the Orionjs app for production").option("--output [path]", "Path of the output file").action(run(build_default));
-program.command("prod").allowUnknownOption().description("Run the Orionjs app in production mode").action(run(prod_default));
+program.command("prod").allowUnknownOption().option(
+  "--path [path]",
+  "Path of the compiled Orionjs app. If not provided, the app will be compiled and then run"
+).description("Run the Orionjs app in production mode").action(run(prod_default));
 program.command("create").description("Creates a new Orionjs project").option("--name [name]", "Name of the project").option("--kit [kit]", "Which starter kit to use").action(run(create_default));
 program.version(version_default, "-v --version");
 program.parse(process.argv);