@granite-js/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,666 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Builtins, Cli } from "clipanion";
+import { cosmiconfig as cosmiconfig2 } from "cosmiconfig";
+
+// src/commands/BuildCommand/BuildCommand.ts
+import { Command, Option } from "clipanion";
+
+// src/build.ts
+import { runBundle } from "@granite-js/mpack";
+import { statusPlugin } from "@granite-js/mpack/plugins";
+import { resolvePlugins } from "@granite-js/plugin-core";
+async function build(config, {
+  tag,
+  cache
+}) {
+  const resolvedPlugins = await resolvePlugins(config.plugins);
+  const pluginContext = {
+    meta: /* @__PURE__ */ Object.create(null)
+  };
+  for (const preHandler of resolvedPlugins.build.preHandlers) {
+    await preHandler?.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir,
+      buildResults: []
+    });
+  }
+  const results = await runBundle({
+    tag,
+    rootDir: config.cwd,
+    dev: false,
+    cache,
+    metafile: true,
+    plugins: [statusPlugin],
+    config: config.mpack.build.config
+  });
+  for (const postHandler of resolvedPlugins.build.postHandlers) {
+    await postHandler?.call(pluginContext, {
+      cwd: config.cwd,
+      entryFile: config.entryFile,
+      appName: config.appName,
+      outdir: config.outdir,
+      buildResults: results
+    });
+  }
+}
+
+// src/config/loadConfig.ts
+import { getPackageRoot } from "@granite-js/utils";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+var MODULE_NAME = "granite";
+var loadConfig = async () => {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: [
+      `${MODULE_NAME}.config.ts`,
+      `${MODULE_NAME}.config.mts`,
+      `${MODULE_NAME}.config.js`,
+      `${MODULE_NAME}.config.cjs`
+    ],
+    loaders: {
+      ".ts": TypeScriptLoader(),
+      ".mts": TypeScriptLoader()
+    }
+  });
+  const result = await explorer.search(getPackageRoot());
+  const config = await result?.config;
+  return config;
+};
+
+// src/commands/BuildCommand/BuildCommand.ts
+var BuildCommand = class extends Command {
+  static paths = [[`build`]];
+  static usage = Command.Usage({
+    category: "Build",
+    description: "Granite App \uBC88\uB4E4\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4",
+    examples: [
+      ["\uBE4C\uB4DC\uD558\uAE30", "granite build"],
+      ["\uC9C0\uC815\uB41C \uB300\uC0C1\uB9CC \uBE4C\uB4DC\uD558\uAE30", "granite build --id service-ios"]
+    ]
+  });
+  tag = Option.String("--tag", {
+    description: "\uAD6C\uC131 \uD30C\uC77C\uC5D0\uC11C \uC9C0\uC815\uD55C \uD0DC\uADF8\uC5D0 \uD574\uB2F9\uD558\uB294 \uB300\uC0C1\uB9CC \uBC88\uB4E4\uB9C1 \uD569\uB2C8\uB2E4"
+  });
+  disableCache = Option.Boolean("--disable-cache", {
+    description: "\uCE90\uC2DC\uB97C \uBE44\uD65C\uC131\uD654 \uD569\uB2C8\uB2E4"
+  });
+  async execute() {
+    try {
+      const { tag, disableCache = false } = this;
+      const config = await loadConfig();
+      await build(config, {
+        tag,
+        cache: !disableCache
+      });
+      return 0;
+    } catch (error) {
+      console.error(error);
+      return 1;
+    }
+  }
+};
+
+// src/commands/HermesCommand/HermesCommand.ts
+import path2 from "path";
+import chalk from "chalk";
+import { Command as Command2, Option as Option2 } from "clipanion";
+
+// src/utils/compileHbc.ts
+import assert from "assert";
+import os from "os";
+import path from "path";
+import { isNotNil } from "es-toolkit";
+import execa from "execa";
+var binary = {
+  Darwin: "react-native/sdks/hermesc/osx-bin/hermesc",
+  Linux: "react-native/sdks/hermesc/linux64-bin/hermesc",
+  Windows_NT: "react-native/sdks/hermesc/win64-bin/hermesc.exe"
+};
+async function compileHbc({ rootDir, filePath, sourcemap }) {
+  const binary2 = getHermesc(rootDir);
+  const outfile = path.resolve(rootDir, filePath.replace(new RegExp(`${path.extname(filePath)}$`), ".hbc"));
+  await execa(
+    binary2,
+    [
+      // Disable warnings
+      "-w",
+      // Expensive optimizations
+      "-O",
+      // Emit binary
+      "-emit-binary",
+      // Emit source map
+      sourcemap ? "-output-source-map" : null,
+      // Output path
+      "-out",
+      outfile,
+      filePath
+    ].filter(isNotNil)
+  );
+  return { outfile, sourcemapOutfile: sourcemap ? `${outfile}.map` : null };
+}
+function getHermesc(rootDir) {
+  const os2 = getOs();
+  const binarySource = binary[os2];
+  assert(binarySource, `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 OS \uC785\uB2C8\uB2E4: ${os2}`);
+  return resolveFromRoot(rootDir, binarySource);
+}
+function getOs() {
+  return os.type();
+}
+function resolveFromRoot(rootDir, request) {
+  return __require.resolve(request, { paths: [rootDir] });
+}
+
+// src/commands/HermesCommand/HermesCommand.ts
+var HermesCommand = class extends Command2 {
+  static paths = [[`hermes`]];
+  static usage = Command2.Usage({
+    category: "Hermes",
+    description: "\uC9C0\uC815\uD55C \uBC88\uB4E4\uC744 Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD569\uB2C8\uB2E4",
+    examples: [["\uCEF4\uD30C\uC77C\uD558\uAE30", "granite hermes --jsbundle dist/bundle.js"]]
+  });
+  jsBundleFile = Option2.String("--jsbundle", {
+    required: true,
+    description: "Hermes \uBC14\uC774\uD2B8 \uCF54\uB4DC\uB85C \uCEF4\uD30C\uC77C \uD560 Javascript \uD30C\uC77C \uACBD\uB85C \uC785\uB2C8\uB2E4"
+  });
+  sourcemap = Option2.Boolean("--sourcemap", true, {
+    description: "\uC18C\uC2A4\uB9F5 \uD30C\uC77C\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4"
+  });
+  async execute() {
+    try {
+      const rootDir = process.cwd();
+      const filePath = path2.resolve(rootDir, this.jsBundleFile);
+      const { outfile, sourcemapOutfile } = await compileHbc({ rootDir, filePath, sourcemap: this.sourcemap });
+      console.log(`\u2705 \uCEF4\uD30C\uC77C \uC644\uB8CC: ${chalk.gray(outfile)}`);
+      if (sourcemapOutfile) {
+        console.log(`\u2705 \uC18C\uC2A4\uB9F5 \uC0DD\uC131 \uC644\uB8CC: ${chalk.gray(sourcemapOutfile)}`);
+      }
+      return 0;
+    } catch (error) {
+      console.error(error.stack);
+      return 1;
+    }
+  }
+};
+
+// src/commands/DevCommand/DevCommand.ts
+import assert2 from "assert";
+import * as mpack from "@granite-js/mpack";
+import { resolvePlugins as resolvePlugins2 } from "@granite-js/plugin-core";
+import { Command as Command3, Option as Option3 } from "clipanion";
+import Debug from "debug";
+
+// src/config/mergeTransformFromPlugins.ts
+async function mergeTransformFromPlugins(plugins) {
+  const mergedTransformFunctions = plugins.reduce(
+    (acc, plugin) => {
+      if (plugin.transformSync) {
+        acc.transformSync.push(plugin.transformSync);
+      }
+      if (plugin.transformAsync) {
+        acc.transformAsync.push(plugin.transformAsync);
+      }
+      return acc;
+    },
+    {
+      transformSync: [],
+      transformAsync: []
+    }
+  );
+  if (mergedTransformFunctions.transformSync.length === 0 && mergedTransformFunctions.transformAsync.length > 0) {
+    console.warn(
+      `Metro is only supported 'transformSync', but ${mergedTransformFunctions.transformAsync.length} 'transformAsync' are detected and it will be ignored.`
+    );
+  }
+  return {
+    transformSync: (id, code) => {
+      return mergedTransformFunctions.transformSync.reduce((acc, transform) => transform?.(id, acc) ?? acc, code);
+    },
+    transformAsync: async (id, code) => {
+      return mergedTransformFunctions.transformAsync.reduce(async (acc, transform) => {
+        return await transform?.(id, await acc) ?? acc;
+      }, Promise.resolve(code));
+    }
+  };
+}
+
+// src/commands/DevCommand/DevCommand.ts
+var debug = Debug("cli");
+var DEFAULT_HOST = "0.0.0.0";
+var DEFAULT_LOCALHOST_PORT = 8081;
+var DevCommand = class extends Command3 {
+  static paths = [[`dev`]];
+  static usage = Command3.Usage({
+    category: "Development",
+    description: "Granite \uAC1C\uBC1C \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4",
+    examples: [["\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589\uD558\uAE30", "granite dev"]]
+  });
+  host = Option3.String("--host");
+  port = Option3.String("--port");
+  disableEmbeddedReactDevTools = Option3.Boolean("--disable-embedded-react-devtools", false);
+  // mpack dev-server
+  experimentalMode = Option3.Boolean("--experimental-mode");
+  preloadBundle = Option3.String("--preload-bundle", {
+    description: "Preload \uD560 \uBC88\uB4E4 \uD30C\uC77C\uC758 \uACBD\uB85C"
+  });
+  async execute() {
+    try {
+      const config = await loadConfig();
+      const serverOptions = {
+        host: this.host,
+        port: this.port ? parseInt(this.port, 10) : void 0
+      };
+      assert2(config?.appName, "\uC571 \uC774\uB984\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+      debug("StartCommand", {
+        ...serverOptions,
+        disableEmbeddedReactDevTools: this.disableEmbeddedReactDevTools,
+        experimentalMode: this.experimentalMode,
+        preloadBundle: this.preloadBundle
+      });
+      if (this.experimentalMode) {
+        const mpackConfig = config.mpack.devServer.config;
+        const mpackDevServerConfig = mpackConfig?.devServer;
+        assert2(mpackDevServerConfig, "mpack dev server \uC124\uC815\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+        await mpack.experimental_runServer({
+          appName: config.appName,
+          scheme: config.scheme,
+          devServerConfig: mpackDevServerConfig,
+          host: serverOptions.host,
+          port: serverOptions.port,
+          preloadBundle: this.preloadBundle
+        });
+      } else {
+        const resolvedPlugins = await resolvePlugins2(config.plugins);
+        const mergedTransform = await mergeTransformFromPlugins(resolvedPlugins.plugins);
+        const additionalMetroConfig = {
+          ...config.metro,
+          transformSync: mergedTransform?.transformSync
+        };
+        for (const preHandler of resolvedPlugins.devServer.preHandlers) {
+          debug("preHandler", preHandler);
+          await preHandler?.({
+            host: serverOptions.host || DEFAULT_HOST,
+            port: serverOptions.port || DEFAULT_LOCALHOST_PORT,
+            appName: config.appName,
+            outdir: config.outdir,
+            cwd: config.cwd,
+            entryFile: config.entryFile
+          });
+        }
+        await mpack.runServer({
+          cwd: config.cwd,
+          host: serverOptions.host,
+          port: serverOptions.port,
+          middlewares: config.mpack.devServer.middlewares,
+          config: config.mpack.devServer.config,
+          onServerReady: async () => {
+            for (const postHandler of resolvedPlugins.devServer.postHandlers) {
+              debug("postHandler", postHandler);
+              await postHandler?.({
+                host: serverOptions.host || DEFAULT_HOST,
+                port: serverOptions.port || DEFAULT_LOCALHOST_PORT,
+                appName: config.appName,
+                outdir: config.outdir,
+                cwd: config.cwd,
+                entryFile: config.entryFile
+              });
+            }
+          },
+          enableEmbeddedReactDevTools: !this.disableEmbeddedReactDevTools,
+          additionalConfig: additionalMetroConfig
+        });
+      }
+    } catch (error) {
+      console.log(`ERROR OCCURRED`);
+      console.log(error);
+      console.log(error.message);
+      console.error(error.stack);
+      process.exit(1);
+    }
+  }
+};
+
+// src/config/defineConfig.ts
+import path4 from "path";
+import {
+  babelConfigSchema,
+  esbuildConfigSchema
+} from "@granite-js/mpack";
+import { flattenPlugins as flattenPlugins2, mpackConfigScheme } from "@granite-js/plugin-core";
+import { getPackageRoot as getPackageRoot2 } from "@granite-js/utils";
+import { merge } from "es-toolkit";
+import { z } from "zod";
+
+// src/config/mergeConfigFromPlugins.ts
+import { flattenPlugins } from "@granite-js/plugin-core";
+import { mergeWith } from "es-toolkit";
+function concatArray(objValue, srcValue) {
+  if (Array.isArray(objValue) && Array.isArray(srcValue)) {
+    return objValue.concat(srcValue);
+  }
+  return;
+}
+function mergeMetroConfig(objValue, srcValue, key) {
+  if (key === "getPolyfills" && typeof objValue === "function" && typeof srcValue === "function") {
+    return () => [...objValue(), ...srcValue()];
+  }
+  return void 0;
+}
+function combineComparers(...fns) {
+  return (targetValue, sourceValue, key, target, source) => {
+    for (const fn of fns) {
+      const result = fn(targetValue, sourceValue, key, target, source);
+      if (result !== void 0) {
+        return result;
+      }
+    }
+    return void 0;
+  };
+}
+async function mergeConfigFromPlugins(plugins) {
+  const pluginsResolved = await flattenPlugins(plugins);
+  return pluginsResolved.reduce(
+    (acc, plugin) => mergeWith(acc, plugin.config ?? {}, combineComparers(concatArray, mergeMetroConfig)),
+    {}
+  );
+}
+
+// src/presets/service.ts
+import { isNotNil as isNotNil2 } from "es-toolkit";
+
+// src/presets/common/graniteRequireProtocol.ts
+var graniteRequireProtocol = {
+  load: (args) => {
+    return { loader: "js", contents: `module.exports = __granite_require__('${args.path}');` };
+  }
+};
+
+// src/presets/common/optimizations.ts
+var resolveTslibEsm = () => ({
+  from: "tslib",
+  to: async ({ resolve, args }) => {
+    const result = await resolve(args.path, {
+      kind: args.kind,
+      resolveDir: args.resolveDir
+    });
+    if (result.errors.length) {
+      throw new Error(`resolveTslibEsm: ${args.path}`);
+    }
+    return result.path.replace(/(tslib\.js|modules\/index\.js)$/, "tslib.es6.js");
+  },
+  exact: true
+});
+var optimizations = { resolveTslibEsm };
+
+// src/presets/common/preludeScripts.ts
+import path3 from "path";
+function getReactNativeSetupScripts(rootDir) {
+  const reactNativePath = path3.dirname(
+    __require.resolve("react-native/package.json", {
+      paths: [rootDir]
+    })
+  );
+  return [
+    ...__require(path3.join(reactNativePath, "rn-get-polyfills"))(),
+    path3.join(reactNativePath, "Libraries/Core/InitializeCore.js")
+  ];
+}
+function getGlobalVariables({ dev = true }) {
+  return {
+    global: "window",
+    __DEV__: JSON.stringify(dev),
+    "process.env.NODE_ENV": JSON.stringify(dev ? "development" : "production")
+  };
+}
+var preludePresets = {
+  globalVariables: ({ dev }) => {
+    return [
+      "var __BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now();",
+      `var __DEV__=${JSON.stringify(dev)};`,
+      `var window=typeof globalThis!=='undefined'?globalThis:typeof global!=='undefined'?global:typeof window!=='undefined'?window:this;`
+    ].join("\n");
+  },
+  graniteSharedEnvironment: ({ buildNumber }) => {
+    return [
+      "window.__granite = window.__granite || {};",
+      `window.__granite.shared = { buildNumber: ${JSON.stringify(buildNumber)} };`
+    ].join("\n");
+  },
+  graniteAppEnvironment: ({
+    appName,
+    scheme,
+    buildNumber
+  }) => {
+    return [
+      "window.__granite = window.__granite || {};",
+      `window.__granite.app = { name: ${JSON.stringify(appName)}, scheme: ${JSON.stringify(scheme)}, buildNumber: ${JSON.stringify(buildNumber)} };`
+    ].join("\n");
+  }
+};
+
+// src/presets/common/babelConditions.ts
+var babelConditions = [
+  /**
+   * @TODO
+   * zod 에서 hermes 가 지원하지 않는 RegExp 를 사용 중이며,
+   * 대응 가능한 swc 구성/플러그인이 존재하지 않기에 babel 로 트랜스파일하도록 합니다
+   *
+   * @see zod {@link https://github.com/colinhacks/zod/issues/2302}
+   */
+  (_code, path5) => path5.includes("node_modules/zod")
+];
+
+// src/presets/utils/getBuildNumber.ts
+function getBuildNumber() {
+  const date = /* @__PURE__ */ new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+
+// src/presets/service.ts
+var DEFAULT_OPTIMIZATION_OPTIONS = {
+  "tslib-esm": false
+};
+function commonResolver({ optimization = DEFAULT_OPTIMIZATION_OPTIONS }) {
+  return {
+    alias: [
+      ...[
+        "@react-navigation/native-stack",
+        "@react-navigation/native",
+        "react-native-safe-area-context",
+        "react-native-screens",
+        "react-native-svg",
+        "react-native-gesture-handler",
+        "react-native",
+        "react"
+      ].map((module) => ({ from: module, to: `granite-require:${module}`, exact: true })),
+      optimization["tslib-esm"] ? optimizations.resolveTslibEsm() : null
+    ].filter(isNotNil2),
+    protocols: {
+      "granite-require": graniteRequireProtocol
+    }
+  };
+}
+function getCommonServicePreset(context, { optimization = DEFAULT_OPTIMIZATION_OPTIONS }) {
+  const { dev } = context;
+  const buildNumber = getBuildNumber();
+  return {
+    resolver: commonResolver({ optimization }),
+    esbuild: {
+      /**
+       * React Native 및 Granite 앱에서 사용되는 전역변수
+       */
+      define: getGlobalVariables({ dev }),
+      banner: {
+        js: [
+          preludePresets.graniteAppEnvironment({
+            appName: context.appName,
+            scheme: context.scheme,
+            buildNumber
+          }),
+          // symbol-asynciterator polyfill (ES5)
+          `(function(){if(typeof Symbol!=="undefined"&&!Symbol.asyncIterator){Symbol.asyncIterator=Symbol.for("@@asyncIterator")}})();`
+        ].join("\n")
+      }
+    },
+    babel: {
+      conditions: babelConditions
+    }
+  };
+}
+var service = (options = {}) => (context) => {
+  return getCommonServicePreset(context, options);
+};
+
+// src/presets/shared.ts
+function getCommonSharedPreset(context) {
+  const { rootDir, dev } = context;
+  const buildNumber = getBuildNumber();
+  return {
+    esbuild: {
+      define: getGlobalVariables({ dev }),
+      banner: {
+        js: [preludePresets.globalVariables({ dev }), preludePresets.graniteSharedEnvironment({ buildNumber })].join(
+          "\n"
+        )
+      },
+      prelude: [...getReactNativeSetupScripts(rootDir)]
+    },
+    babel: {
+      conditions: babelConditions
+    }
+  };
+}
+var shared = () => (context) => {
+  return getCommonSharedPreset(context);
+};
+
+// src/config/defineConfig.ts
+var graniteConfigSchema = z.object({
+  appName: z.string(),
+  scheme: z.string(),
+  plugins: z.custom(),
+  outdir: z.string().default("dist"),
+  entryFile: z.string().default("./src/_app.tsx"),
+  cwd: z.string().default(process.cwd()),
+  mpack: mpackConfigScheme.optional(),
+  babel: babelConfigSchema.optional(),
+  esbuild: esbuildConfigSchema.optional(),
+  metro: z.custom().optional(),
+  INTERNAL__useSharedPreset: z.boolean().optional()
+});
+var defineConfig = async (config) => {
+  const parsedConfig = graniteConfigSchema.parse(config);
+  const appName = parsedConfig.appName;
+  const scheme = parsedConfig.scheme;
+  const outdir = path4.join(getPackageRoot2(), parsedConfig.outdir);
+  const entryFile = parsedConfig.entryFile;
+  const plugins = await flattenPlugins2(parsedConfig.plugins);
+  const mergedConfig = await mergeConfigFromPlugins(plugins);
+  const mergedTransform = await mergeTransformFromPlugins(plugins);
+  const esbuild = mergedConfig?.esbuild ? merge(mergedConfig.esbuild, parsedConfig?.esbuild ?? {}) : void 0;
+  const metro = mergedConfig?.metro ? merge(mergedConfig.metro, parsedConfig?.metro ?? {}) : void 0;
+  const babel = mergedConfig?.babel ? merge(mergedConfig.babel, parsedConfig?.babel ?? {}) : void 0;
+  const mpackDevServer = mergedConfig?.mpack?.devServer ? merge(mergedConfig?.mpack?.devServer ?? {}, parsedConfig?.mpack?.devServer ?? {}) : void 0;
+  const buildPreset = config.INTERNAL__useSharedPreset ? shared : service;
+  const createTask = (platform) => ({
+    tag: `${appName}-${platform}`,
+    presets: [buildPreset()],
+    build: {
+      esbuild,
+      babel,
+      platform,
+      entry: entryFile,
+      outfile: path4.join(outdir, `bundle.${platform}.js`),
+      transformSync: mergedTransform?.transformSync,
+      transformAsync: mergedTransform?.transformAsync
+    }
+  });
+  return {
+    ...parsedConfig,
+    outdir,
+    mpack: {
+      devServer: {
+        middlewares: mpackDevServer?.middlewares ?? [],
+        config: {
+          appName,
+          scheme,
+          services: {
+            /* TODO: Plugin 구조로 변경 필요 */
+            sentry: {
+              enabled: false
+            }
+          },
+          devServer: {
+            presets: [buildPreset()],
+            build: {
+              entry: entryFile
+            }
+          },
+          tasks: []
+        }
+      },
+      build: {
+        config: {
+          appName,
+          scheme,
+          services: {
+            /* TODO: Plugin 구조로 변경 필요 */
+            sentry: {
+              enabled: false
+            }
+          },
+          concurrency: 2,
+          tasks: [createTask("ios"), createTask("android")]
+        }
+      }
+    },
+    metro: {
+      ...metro,
+      babelConfig: babel,
+      transformSync: mergedTransform?.transformSync
+    }
+  };
+};
+
+// src/index.ts
+var cli = new Cli({
+  binaryLabel: "granite",
+  binaryName: "granite",
+  enableCapture: true
+});
+async function initialize() {
+  const explorer = await cosmiconfig2("mpack");
+  const result = await explorer.search(process.cwd());
+  cli.register(BuildCommand);
+  cli.register(HermesCommand);
+  cli.register(DevCommand);
+  cli.register(Builtins.HelpCommand);
+  if (Array.isArray(result?.config?.commands)) {
+    (result?.config?.commands).forEach((command) => cli.register(command));
+  }
+  cli.runExit(process.argv.slice(2));
+}
+export {
+  commonResolver,
+  defineConfig,
+  getGlobalVariables,
+  initialize,
+  loadConfig,
+  service
+};