studiocms 0.1.0-beta.10

package/dist/cli/cmds/init/steps/envBuilder.js

@@ -0,0 +1,368 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import color from "chalk";
+import { commandExists, runInteractiveCommand, runShellCommand } from "../../../lib/runExternal.js";
+import {
+  StudioCMSColorwayError,
+  StudioCMSColorwayInfo,
+  StudioCMSColorwayWarnBg,
+  TursoColorway,
+  exists,
+  label
+} from "../../../lib/utils.js";
+import { ExampleEnv, buildEnvFile } from "./data/studiocmsEnv.js";
+async function env(ctx) {
+  ctx.debug && ctx.logger.debug("Running env...");
+  let _env = false;
+  let envFileContent;
+  const envExists = exists(path.join(ctx.cwd, ".env"));
+  ctx.debug && ctx.logger.debug(`Environment file exists: ${envExists}`);
+  if (envExists) {
+    ctx.p.log.warn(
+      `${label("Warning", StudioCMSColorwayWarnBg, color.black)} An environment file already exists. Would you like to overwrite it?`
+    );
+    const check = await ctx.p.confirm({
+      message: "Confirm Overwrite"
+    });
+    if (typeof check === "symbol") {
+      ctx.pCancel(check);
+    } else {
+      ctx.debug && ctx.logger.debug(`Environment file overwrite selected: ${check}`);
+      if (!check) {
+        return;
+      }
+    }
+  }
+  const EnvPrompt = await ctx.p.select({
+    message: "What kind of environment file would you like to create?",
+    options: [
+      { value: "builder", label: "Use Interactive .env Builder" },
+      { value: "example", label: "Use the Example .env file" },
+      { value: "none", label: "Skip Environment File Creation", hint: "Cancel" }
+    ]
+  });
+  if (typeof EnvPrompt === "symbol") {
+    ctx.pCancel(EnvPrompt);
+  } else {
+    ctx.debug && ctx.logger.debug(`Environment file type selected: ${EnvPrompt}`);
+    _env = EnvPrompt !== "none";
+  }
+  if (EnvPrompt === "example") {
+    envFileContent = ExampleEnv;
+  } else if (EnvPrompt === "builder") {
+    let envBuilderOpts = {};
+    const isWindows = os.platform() === "win32";
+    if (isWindows) {
+      ctx.p.log.warn(
+        `${label("Warning", StudioCMSColorwayWarnBg, color.black)} Turso DB CLI is not supported on Windows outside of WSL.`
+      );
+    }
+    let tursoDB = "no";
+    if (!isWindows) {
+      tursoDB = await ctx.p.select({
+        message: "Would you like us to setup a new Turso DB for you? (Runs `turso db create`)",
+        options: [
+          { value: "yes", label: "Yes" },
+          { value: "no", label: "No" }
+        ]
+      });
+    }
+    if (typeof tursoDB === "symbol") {
+      ctx.pCancel(tursoDB);
+    } else {
+      ctx.debug && ctx.logger.debug(`AstroDB setup selected: ${tursoDB}`);
+      if (tursoDB === "yes") {
+        if (!commandExists("turso")) {
+          ctx.p.log.error(StudioCMSColorwayError("Turso CLI is not installed."));
+          const installTurso = await ctx.p.confirm({
+            message: "Would you like to install Turso CLI now?"
+          });
+          if (typeof installTurso === "symbol") {
+            ctx.pCancel(installTurso);
+          } else {
+            if (installTurso) {
+              try {
+                await runInteractiveCommand("curl -sSfL https://get.tur.so/install.sh | bash");
+                console.log("Command completed successfully.");
+              } catch (error) {
+                console.error(`Failed to run Turso install: ${error.message}`);
+              }
+            } else {
+              ctx.p.log.warn(
+                `${label("Warning", StudioCMSColorwayWarnBg, color.black)} You will need to setup your own AstroDB and provide the URL and Token.`
+              );
+            }
+          }
+        }
+        try {
+          const res = await runShellCommand("turso auth login --headless");
+          if (!res.includes("Already signed in as") && !res.includes("Success! Existing JWT still valid")) {
+            ctx.p.log.message(`Please sign in to Turso to continue.
+${res}`);
+            const loginToken = await ctx.p.text({
+              message: 'Enter the login token ( the code within the " " )',
+              placeholder: "eyJhb...tnPnw"
+            });
+            if (typeof loginToken === "symbol") {
+              ctx.pCancel(loginToken);
+            } else {
+              const loginRes = await runShellCommand(`turso config set token "${loginToken}"`);
+              if (loginRes.includes("Token set succesfully.")) {
+                ctx.p.log.success("Successfully logged in to Turso.");
+              } else {
+                ctx.p.log.error(StudioCMSColorwayError("Unable to login to Turso."));
+                process.exit(1);
+              }
+            }
+          }
+        } catch (error) {
+          if (error instanceof Error) {
+            ctx.p.log.error(StudioCMSColorwayError(`Error: ${error.message}`));
+            process.exit(1);
+          } else {
+            ctx.p.log.error(StudioCMSColorwayError("Unknown Error: Unable to login to Turso."));
+            process.exit(1);
+          }
+        }
+        const customName = await ctx.p.confirm({
+          message: "Would you like to provide a custom name for the database?",
+          initialValue: false
+        });
+        if (typeof customName === "symbol") {
+          ctx.pCancel(customName);
+        } else {
+          const dbName = customName ? await ctx.p.text({
+            message: "Enter a custom name for the database",
+            initialValue: "your-database-name"
+          }) : void 0;
+          if (typeof dbName === "symbol") {
+            ctx.pCancel(dbName);
+          } else {
+            ctx.debug && ctx.logger.debug(`Custom database name: ${dbName}`);
+            const tursoSetup = ctx.p.spinner();
+            tursoSetup.start(
+              `${label("Turso", TursoColorway, color.black)} Setting up Turso DB...`
+            );
+            try {
+              tursoSetup.message(
+                `${label("Turso", TursoColorway, color.black)} Creating Database...`
+              );
+              const createRes = await runShellCommand(`turso db create ${dbName ? dbName : ""}`);
+              const dbNameMatch = createRes.match(/^Created database (\S+) at group/m);
+              const dbFinalName = dbNameMatch ? dbNameMatch[1] : void 0;
+              tursoSetup.message(
+                `${label("Turso", TursoColorway, color.black)} Retrieving database information...`
+              );
+              ctx.debug && ctx.logger.debug(`Database name: ${dbFinalName}`);
+              const showCMD = `turso db show ${dbFinalName}`;
+              const tokenCMD = `turso db tokens create ${dbFinalName}`;
+              const showRes = await runShellCommand(showCMD);
+              const urlMatch = showRes.match(/^URL:\s+(\S+)/m);
+              const dbURL = urlMatch ? urlMatch[1] : void 0;
+              ctx.debug && ctx.logger.debug(`Database URL: ${dbURL}`);
+              const tokenRes = await runShellCommand(tokenCMD);
+              const dbToken = tokenRes.trim();
+              ctx.debug && ctx.logger.debug(`Database Token: ${dbToken}`);
+              envBuilderOpts.astroDbRemoteUrl = dbURL;
+              envBuilderOpts.astroDbToken = dbToken;
+              tursoSetup.stop(
+                `${label("Turso", TursoColorway, color.black)} Database setup complete. New Database: ${dbFinalName}`
+              );
+              ctx.p.log.message("Database Token and Url saved to environment file.");
+            } catch (e) {
+              tursoSetup.stop();
+              if (e instanceof Error) {
+                ctx.p.log.error(StudioCMSColorwayError(`Error: ${e.message}`));
+                process.exit(1);
+              } else {
+                ctx.p.log.error(
+                  StudioCMSColorwayError("Unknown Error: Unable to create database.")
+                );
+                process.exit(1);
+              }
+            }
+          }
+        }
+      } else {
+        ctx.p.log.warn(
+          `${label("Warning", StudioCMSColorwayWarnBg, color.black)} You will need to setup your own AstroDB and provide the URL and Token.`
+        );
+        const envBuilderStep_AstroDB = await ctx.p.group(
+          {
+            astroDbRemoteUrl: () => ctx.p.text({
+              message: "Remote URL for AstroDB",
+              initialValue: "libsql://your-database.turso.io"
+            }),
+            astroDbToken: () => ctx.p.text({
+              message: "AstroDB Token",
+              initialValue: "your-astrodb-token"
+            })
+          },
+          {
+            onCancel: () => ctx.pOnCancel()
+          }
+        );
+        ctx.debug && ctx.logger.debug(`AstroDB setup: ${envBuilderStep_AstroDB}`);
+        envBuilderOpts = { ...envBuilderStep_AstroDB };
+      }
+    }
+    const envBuilderStep1 = await ctx.p.group(
+      {
+        encryptionKey: () => ctx.p.text({
+          message: "StudioCMS Auth Encryption Key",
+          initialValue: crypto.randomBytes(16).toString("base64")
+        }),
+        oAuthOptions: () => ctx.p.multiselect({
+          message: "Setup OAuth Providers",
+          options: [
+            { value: "github", label: "GitHub" },
+            { value: "discord", label: "Discord" },
+            { value: "google", label: "Google" },
+            { value: "auth0", label: "Auth0" }
+          ],
+          required: false
+        })
+      },
+      {
+        // On Cancel callback that wraps the group
+        // So if the user cancels one of the prompts in the group this function will be called
+        onCancel: () => ctx.pOnCancel()
+      }
+    );
+    ctx.debug && ctx.logger.debug(`Environment Builder Step 1: ${envBuilderStep1}`);
+    envBuilderOpts = { ...envBuilderStep1 };
+    if (envBuilderStep1.oAuthOptions.includes("github")) {
+      const githubOAuth = await ctx.p.group(
+        {
+          clientId: () => ctx.p.text({
+            message: "GitHub Client ID",
+            initialValue: "your-github-client-id"
+          }),
+          clientSecret: () => ctx.p.text({
+            message: "GitHub Client Secret",
+            initialValue: "your-github-client-secret"
+          }),
+          redirectUri: () => ctx.p.text({
+            message: "GitHub Redirect URI Domain",
+            initialValue: "http://localhost:4321"
+          })
+        },
+        {
+          onCancel: () => ctx.pOnCancel()
+        }
+      );
+      ctx.debug && ctx.logger.debug(`GitHub OAuth: ${githubOAuth}`);
+      envBuilderOpts.githubOAuth = githubOAuth;
+    }
+    if (envBuilderStep1.oAuthOptions.includes("discord")) {
+      const discordOAuth = await ctx.p.group(
+        {
+          clientId: () => ctx.p.text({
+            message: "Discord Client ID",
+            initialValue: "your-discord-client-id"
+          }),
+          clientSecret: () => ctx.p.text({
+            message: "Discord Client Secret",
+            initialValue: "your-discord-client-secret"
+          }),
+          redirectUri: () => ctx.p.text({
+            message: "Discord Redirect URI Domain",
+            initialValue: "http://localhost:4321"
+          })
+        },
+        {
+          onCancel: () => ctx.pOnCancel()
+        }
+      );
+      ctx.debug && ctx.logger.debug(`Discord OAuth: ${discordOAuth}`);
+      envBuilderOpts.discordOAuth = discordOAuth;
+    }
+    if (envBuilderStep1.oAuthOptions.includes("google")) {
+      const googleOAuth = await ctx.p.group(
+        {
+          clientId: () => ctx.p.text({
+            message: "Google Client ID",
+            initialValue: "your-google-client-id"
+          }),
+          clientSecret: () => ctx.p.text({
+            message: "Google Client Secret",
+            initialValue: "your-google-client-secret"
+          }),
+          redirectUri: () => ctx.p.text({
+            message: "Google Redirect URI Domain",
+            initialValue: "http://localhost:4321"
+          })
+        },
+        {
+          onCancel: () => ctx.pOnCancel()
+        }
+      );
+      ctx.debug && ctx.logger.debug(`Google OAuth: ${googleOAuth}`);
+      envBuilderOpts.googleOAuth = googleOAuth;
+    }
+    if (envBuilderStep1.oAuthOptions.includes("auth0")) {
+      const auth0OAuth = await ctx.p.group(
+        {
+          clientId: () => ctx.p.text({
+            message: "Auth0 Client ID",
+            initialValue: "your-auth0-client-id"
+          }),
+          clientSecret: () => ctx.p.text({
+            message: "Auth0 Client Secret",
+            initialValue: "your-auth0-client-secret"
+          }),
+          domain: () => ctx.p.text({
+            message: "Auth0 Domain",
+            initialValue: "your-auth0-domain"
+          }),
+          redirectUri: () => ctx.p.text({
+            message: "Auth0 Redirect URI Domain",
+            initialValue: "http://localhost:4321"
+          })
+        },
+        {
+          onCancel: () => ctx.pOnCancel()
+        }
+      );
+      ctx.debug && ctx.logger.debug(`Auth0 OAuth: ${auth0OAuth}`);
+      envBuilderOpts.auth0OAuth = auth0OAuth;
+    }
+    envFileContent = buildEnvFile(envBuilderOpts);
+  }
+  if (ctx.dryRun) {
+    ctx.tasks.push({
+      title: `${StudioCMSColorwayInfo.bold("--dry-run")} ${color.dim("Skipping environment file creation")}`,
+      task: async (message) => {
+        message("Creating environment file... (skipped)");
+      }
+    });
+  } else if (_env) {
+    ctx.tasks.push({
+      title: color.dim("Creating environment file..."),
+      task: async (message) => {
+        try {
+          await fs.writeFile(path.join(ctx.cwd, ".env"), envFileContent, {
+            encoding: "utf-8"
+          });
+          message("Environment file created");
+        } catch (e) {
+          if (e instanceof Error) {
+            ctx.p.log.error(StudioCMSColorwayError(`Error: ${e.message}`));
+            process.exit(1);
+          } else {
+            ctx.p.log.error(
+              StudioCMSColorwayError("Unknown Error: Unable to create environment file.")
+            );
+            process.exit(1);
+          }
+        }
+      }
+    });
+  }
+  ctx.debug && ctx.logger.debug("Environment complete");
+}
+export {
+  env
+};

package/dist/cli/cmds/init/steps/nextSteps.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../../lib/context.js';
+export declare function next(ctx: Pick<Context, 'cwd' | 'packageManager' | 'skipBanners' | 'debug' | 'logger' | 'p'>): Promise<void>;

package/dist/cli/cmds/init/steps/nextSteps.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import {
+  StudioCMSColorway,
+  StudioCMSColorwayBg,
+  StudioCMSColorwayInfoBg,
+  boxen,
+  label
+} from "../../../lib/utils.js";
+async function next(ctx) {
+  const commandMap = {
+    npm: "npm run dev",
+    bun: "bun run dev",
+    yarn: "yarn dev",
+    pnpm: "pnpm dev"
+  };
+  const devCmd = commandMap[ctx.packageManager] || "npm run dev";
+  ctx.debug && ctx.logger.debug(`Dev command: ${devCmd}`);
+  ctx.debug && ctx.logger.debug("Running next steps fn...");
+  ctx.p.log.success(
+    boxen(
+      chalk.bold(
+        `${label("Init Complete!", StudioCMSColorwayInfoBg, chalk.bold)} Get started with StudioCMS:`
+      ),
+      {
+        ln1: `Ensure your ${chalk.cyanBright(".env")} file is configured correctly.`,
+        ln3: `Run ${chalk.cyan("astro db push")} to sync your database schema.`,
+        ln4: `Run ${chalk.cyan(devCmd)} to start the dev server. ${chalk.cyanBright("CTRL+C")} to stop.`
+      }
+    )
+  );
+  ctx.p.outro(
+    `${label("Enjoy your new CMS!", StudioCMSColorwayBg, chalk.bold)} Stuck? Join us on Discord at ${StudioCMSColorway.bold.underline("https://chat.studiocms.dev")}`
+  );
+  ctx.debug && ctx.logger.debug("Next steps complete");
+}
+export {
+  next
+};

package/dist/cli/cmds/init.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/cmds/init.js

@@ -0,0 +1,4 @@
+import { Option } from "@commander-js/extra-typings";
+import { Command } from "../lib/commander.js";
+import { initCMD } from "./init/index.js";
+await new Command("init").description("Initialize the StudioCMS project after new installation.").summary("Initialize StudioCMS Project").option("-d, --dry-run", "Dry run mode.").option("--skip-banners", "Skip all banners.").addOption(new Option("--debug", "Enable debug mode.").hideHelp(true)).action(initCMD).parseAsync();

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/index.js

@@ -0,0 +1,9 @@
+import { Option } from "@commander-js/extra-typings";
+import { Command } from "./lib/commander.js";
+import pathUtil from "./lib/pathUtil.js";
+import { CLITitle, readJson } from "./lib/utils.js";
+const pkgJson = readJson(new URL("../../package.json", import.meta.url));
+const { getRelPath } = pathUtil(import.meta.url);
+await new Command("studiocms").description("StudioCMS CLI Utility Toolkit").version(pkgJson.version).addHelpText("beforeAll", CLITitle).showHelpAfterError("(add --help for additional information)").enablePositionalOptions(true).executableDir(getRelPath("cmds")).helpOption("-h, --help", "Display help for command.").addOption(new Option("--color", "Force color output")).addOption(new Option("--no-color", "Disable color output")).command("init", "Initialize the StudioCMS project after new installation.", {
+  executableFile: "init.js"
+}).command("get-turso", "Turso CLI Utilities", { executableFile: "get-turso.js" }).parseAsync();

package/dist/cli/lib/commander.d.ts

@@ -0,0 +1,39 @@
+import { type CommandUnknownOpts, type OutputConfiguration, Command as _Command, Help as _Help } from '@commander-js/extra-typings';
+import { type ChalkInstance } from 'chalk';
+export declare class Help extends _Help {
+    chalk: ChalkInstance;
+    colorway: ChalkInstance;
+    colorwayError: ChalkInstance;
+    sortOptions: boolean;
+    sortSubcommands: boolean;
+    showGlobalOptions: boolean;
+    subcommandTerm: (cmd: CommandUnknownOpts) => string;
+    subcommandDescription: (cmd: CommandUnknownOpts) => string;
+    constructor();
+    prepareContext(contextOptions: {
+        error?: boolean;
+        helpWidth?: number;
+        outputHasColors?: boolean;
+    }): void;
+    displayWidth(str: string): number;
+    boxWrap(str: string, width: number): string;
+    styleTitle(str: string): string;
+    styleCommandText(str: string): string;
+    styleCommandDescription(str: string): string;
+    styleDescriptionText(str: string): string;
+    styleOptionText(str: string): string;
+    styleArgumentText(str: string): string;
+    styleSubcommandText(str: string): string;
+}
+export declare class Command extends _Command {
+    chalk: ChalkInstance;
+    colorwayError: ChalkInstance;
+    supportsColor: boolean;
+    max: number;
+    prefix: string;
+    _outputConfiguration: OutputConfiguration | undefined;
+    createCommand(name: string | undefined): Command;
+    createHelp(): Help & Partial<_Help>;
+}
+export type newInstanceCommand = InstanceType<typeof Command>;
+export type instanceCommand = InstanceType<typeof _Command>;

package/dist/cli/lib/commander.js

@@ -0,0 +1,87 @@
+import {
+  Command as _Command,
+  Help as _Help
+} from "@commander-js/extra-typings";
+import { chalkStderr as chalkStdErr, default as chalkStdOut } from "chalk";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+import { StudioCMSColorwayError, date, supportsColor } from "./utils.js";
+class Help extends _Help {
+  chalk;
+  colorway;
+  colorwayError = StudioCMSColorwayError;
+  sortOptions = true;
+  sortSubcommands = true;
+  showGlobalOptions = true;
+  subcommandTerm = (cmd) => cmd.name() === "interactive" ? `${this.colorway(cmd.name())}${this.colorwayError("*")}` : this.colorway(cmd.name());
+  subcommandDescription = (cmd) => {
+    const desc = cmd.summary() || cmd.description();
+    return desc;
+  };
+  constructor() {
+    super();
+    this.chalk = chalkStdOut;
+    this.colorway = this.chalk.hex("#a581f3");
+  }
+  prepareContext(contextOptions) {
+    super.prepareContext(contextOptions);
+    if (contextOptions?.error) {
+      this.chalk = chalkStdErr;
+    }
+  }
+  displayWidth(str) {
+    return stripAnsi(str).length;
+  }
+  boxWrap(str, width) {
+    return wrapAnsi(str, width, { hard: true });
+  }
+  styleTitle(str) {
+    return this.chalk.bold(str);
+  }
+  styleCommandText(str) {
+    return this.chalk.cyan(str);
+  }
+  styleCommandDescription(str) {
+    return this.chalk.magenta(str);
+  }
+  styleDescriptionText(str) {
+    return this.chalk.italic(str);
+  }
+  styleOptionText(str) {
+    return this.chalk.green(str);
+  }
+  styleArgumentText(str) {
+    return this.chalk.yellow(str);
+  }
+  styleSubcommandText(str) {
+    return str;
+  }
+}
+class Command extends _Command {
+  chalk = chalkStdOut;
+  colorwayError = StudioCMSColorwayError;
+  supportsColor = supportsColor;
+  max = process.stdout.columns;
+  prefix = this.max < 80 ? " " : " ".repeat(2);
+  _outputConfiguration = {
+    writeOut: (str) => process.stdout.write(str),
+    writeErr: (str) => process.stdout.write(`ERROR [${date}]: ${str}`),
+    // Output errors in red.
+    outputError: (str, write) => write(`${this.chalk.red.bold(`ERROR [${date}]:`)} ${this.chalk.red(str)}`),
+    getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns ?? 80 : 80,
+    getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns ?? 80 : 80,
+    getOutHasColors: () => this.supportsColor,
+    getErrHasColors: () => this.supportsColor,
+    stripColor: (str) => stripAnsi(str)
+  };
+  createCommand(name) {
+    return new Command(name);
+  }
+  createHelp() {
+    return Object.assign(new Help(), this.configureHelp());
+  }
+}
+export {
+  Command,
+  Help
+};

package/dist/cli/lib/context.d.ts

@@ -0,0 +1,28 @@
+import * as p from '@clack/prompts';
+import colors from 'chalk';
+import { logger } from './utils.js';
+interface BaseContext {
+    p: typeof p;
+    c: typeof colors;
+    pCancel(val: symbol): void;
+    pOnCancel(): void;
+    cwd: string;
+    packageManager: string;
+    username: string;
+    version: string;
+    exit(code: number): never;
+    tasks: p.Task[];
+    logger: typeof logger;
+    welcome: string;
+}
+interface InteractiveOptions {
+    dryRun?: boolean;
+    skipBanners?: boolean;
+    debug?: boolean;
+}
+export interface Context extends BaseContext, InteractiveOptions {
+}
+export declare function getContext(args: InteractiveOptions): Promise<Context>;
+export declare const random: (...arr: any[]) => any;
+export declare function detectPackageManager(): string | undefined;
+export {};

package/dist/cli/lib/context.js

@@ -0,0 +1,55 @@
+import os from "node:os";
+import * as p from "@clack/prompts";
+import colors from "chalk";
+import getSeasonalMessages from "./seasonal.js";
+import { cancelMessage, getName, logger, readJson } from "./utils.js";
+const pkgJson = readJson(new URL("../../../package.json", import.meta.url));
+async function getContext(args) {
+  let { debug, dryRun, skipBanners } = args;
+  const packageManager = detectPackageManager() ?? "npm";
+  const cwd = process.cwd();
+  const { messages } = getSeasonalMessages();
+  skipBanners = !!((os.platform() === "win32" || skipBanners) && !process.env.CI);
+  const context = {
+    p,
+    c: colors,
+    pCancel(val) {
+      p.isCancel(val);
+      p.cancel(cancelMessage);
+      process.exit(0);
+    },
+    pOnCancel() {
+      p.cancel(cancelMessage);
+      process.exit(0);
+    },
+    packageManager,
+    username: await getName(),
+    version: pkgJson.version,
+    welcome: random(messages),
+    dryRun,
+    debug,
+    cwd,
+    skipBanners,
+    exit(code) {
+      process.exit(code);
+    },
+    tasks: [],
+    logger
+  };
+  return context;
+}
+const random = (...arr) => {
+  const flattenedArray = arr.flat(1);
+  return flattenedArray[Math.floor(flattenedArray.length * Math.random())];
+};
+function detectPackageManager() {
+  if (!process.env.npm_config_user_agent) return;
+  const specifier = process.env.npm_config_user_agent.split(" ")[0];
+  const name = specifier.substring(0, specifier.lastIndexOf("/"));
+  return name === "npminstall" ? "cnpm" : name;
+}
+export {
+  detectPackageManager,
+  getContext,
+  random
+};

package/dist/cli/lib/pathUtil.d.ts

@@ -0,0 +1,5 @@
+export default function pathUtil(importMetaUrl: string): {
+    filename: string;
+    dirname: string;
+    getRelPath: (...url: string[]) => string;
+};

package/dist/cli/lib/pathUtil.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function pathUtil(importMetaUrl) {
+  const filename = fileURLToPath(importMetaUrl);
+  const dirname = path.dirname(filename);
+  return {
+    filename,
+    dirname,
+    getRelPath: (...url) => path.join(dirname, ...url)
+  };
+}
+export {
+  pathUtil as default
+};