studiocms 0.1.0-beta.7 → 0.1.0-beta.8

package/custom-renderers/markdocRenderers/markdocReact.ts

@@ -0,0 +1,56 @@
+import reactRenderer from '@astrojs/react/server.js';
+import Markdoc, { type RenderableTreeNode } from '@markdoc/markdoc';
+import { experimental_AstroContainer as AstroContainer } from 'astro/container';
+import * as React from 'react';
+import type { MarkdocRenderer } from 'studiocms/schemas/renderer';
+import ReactWrapper from './markdocReact-components/MarkDocReactWrapper.astro';
+
+/**
+ * MarkDoc React Components
+ *
+ * The React components to use for rendering the content
+ *
+ * @type {Object} - The React components to use for rendering the content
+ */
+// biome-ignore lint/complexity/noBannedTypes: This is a valid use case for `any`
+export type markdocReactComponents = {} | undefined;
+
+/**
+ * MarkDoc Render for React
+ *
+ * @requires `@astrojs/react` - Astro React Integration
+ * @param components - The React components to use for rendering the content
+ * @returns The MarkDoc React Renderer for StudioCMS MarkDoc
+ */
+export function markDocRenderReact(components?: markdocReactComponents): MarkdocRenderer {
+	return {
+		name: 'react',
+		renderer: async (content: RenderableTreeNode) => {
+			// Create an Astro container
+			const container = await AstroContainer.create();
+
+			// Add the Astro React server renderer
+			container.addServerRenderer({
+				name: '@astrojs/react',
+				renderer: reactRenderer,
+			});
+
+			// Add the Astro React client renderer
+			container.addClientRenderer({
+				name: '@astrojs/react',
+				entrypoint: '@astrojs/react/client.js',
+			});
+
+			// Return the rendered content
+			return await container.renderToString(ReactWrapper, {
+				props: {
+					content: Markdoc.renderers.react(content, React, {
+						components,
+					}),
+				},
+			});
+		},
+	};
+}
+
+export default markDocRenderReact;

package/dist/cli/cmds/get-turso.d.ts

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

package/dist/cli/cmds/get-turso.js

@@ -0,0 +1,10 @@
+import { Command } from "../lib/commander.js";
+import { runInteractiveCommand } from "../lib/runExternal";
+await new Command("getTurso").description("Turso CLI Utilities").summary("Turso CLI Utilities").action(async () => {
+  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}`);
+  }
+}).parseAsync();

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

@@ -0,0 +1,4 @@
+import type { instanceCommand } from '../../lib/commander.js';
+import { getContext } from '../../lib/context.js';
+export { getContext };
+export declare function initCMD(this: instanceCommand): Promise<void>;

package/dist/cli/cmds/init/index.js

@@ -0,0 +1,52 @@
+import color from "chalk";
+import { getContext } from "../../lib/context.js";
+import { StudioCMSColorwayBg, label } from "../../lib/utils.js";
+import { intro } from "../../shared/intro.js";
+import { env } from "./steps/envBuilder.js";
+import { next } from "./steps/nextSteps.js";
+async function initCMD() {
+  const opts = this.opts();
+  const ctx = await getContext(opts);
+  ctx.logger.log("Starting interactive CLI...");
+  ctx.debug && ctx.logger.debug(`Options: ${JSON.stringify(opts, null, 2)}`);
+  ctx.debug && ctx.logger.debug(`Context: ${JSON.stringify(ctx, null, 2)}`);
+  console.log("");
+  ctx.debug && ctx.logger.debug("Running interactive CLI Steps...");
+  ctx.p.intro(
+    `${label("StudioCMS", StudioCMSColorwayBg, color.black)} Interactive CLI - initializing...`
+  );
+  await intro(ctx);
+  const steps = [];
+  ctx.debug && ctx.logger.debug("Running Option selection...");
+  const options = await ctx.p.multiselect({
+    message: "What would you like to do? (Select all that apply)",
+    options: [{ value: "env", label: "Setup Environment File", hint: "Create a .env file" }]
+  });
+  if (typeof options === "symbol") {
+    ctx.pCancel(options);
+  } else {
+    options.includes("env") && steps.push(env);
+  }
+  ctx.debug && ctx.logger.debug("Running steps...");
+  if (steps.length === 0) {
+    ctx.p.log.error("No steps selected, exiting...");
+    ctx.exit(0);
+  }
+  for (const step of steps) {
+    await step(ctx);
+  }
+  ctx.debug && ctx.logger.debug("Running tasks...");
+  if (ctx.tasks.length === 0) {
+    ctx.p.log.error("No tasks selected, exiting...");
+    ctx.exit(0);
+  }
+  await ctx.p.tasks(ctx.tasks);
+  ctx.debug && ctx.logger.debug("Running next steps...");
+  await next(ctx);
+  ctx.debug && ctx.logger.debug("Interactive CLI completed, exiting...");
+  ctx.exit(0);
+}
+export {
+  getContext,
+  initCMD
+};

package/dist/cli/cmds/init/steps/data/studiocmsEnv.d.ts

@@ -0,0 +1,3 @@
+import type { EnvBuilderOptions } from '../envBuilder.js';
+export declare const ExampleEnv: string;
+export declare function buildEnvFile(envBuilderOpts: EnvBuilderOptions): string;

package/dist/cli/cmds/init/steps/data/studiocmsEnv.js

@@ -0,0 +1,71 @@
+const ExampleEnv = `# StudioCMS Environment Variables
+
+# libSQL URL and Token for AstroDB
+ASTRO_DB_REMOTE_URL=libsql://your-database.turso.io
+ASTRO_DB_APP_TOKEN=
+
+# Auth encryption key
+CMS_ENCRYPTION_KEY="..." # openssl rand --base64 16
+
+# credentials for GitHub OAuth
+CMS_GITHUB_CLIENT_ID=
+CMS_GITHUB_CLIENT_SECRET=
+CMS_GITHUB_REDIRECT_URI=http://localhost:4321/studiocms_api/auth/github/callback
+
+# credentials for Discord OAuth
+CMS_DISCORD_CLIENT_ID=
+CMS_DISCORD_CLIENT_SECRET=
+CMS_DISCORD_REDIRECT_URI=http://localhost:4321/studiocms_api/auth/discord/callback
+
+# credentials for Google OAuth
+CMS_GOOGLE_CLIENT_ID=
+CMS_GOOGLE_CLIENT_SECRET=
+CMS_GOOGLE_REDIRECT_URI=http://localhost:4321/studiocms_api/auth/google/callback
+
+# credentials for auth0 OAuth
+CMS_AUTH0_CLIENT_ID=
+CMS_AUTH0_CLIENT_SECRET=
+CMS_AUTH0_DOMAIN=
+CMS_AUTH0_REDIRECT_URI=http://localhost:4321/studiocms_api/auth/auth0/callback
+
+## Cloudinary Javascript SDK
+CMS_CLOUDINARY_CLOUDNAME="demo"`;
+function buildEnvFile(envBuilderOpts) {
+  return `# StudioCMS Environment Variables
+
+# libSQL URL and Token for AstroDB
+ASTRO_DB_REMOTE_URL=${envBuilderOpts.astroDbRemoteUrl}
+ASTRO_DB_APP_TOKEN=${envBuilderOpts.astroDbToken}
+
+# Auth encryption key
+CMS_ENCRYPTION_KEY="${envBuilderOpts.encryptionKey}" # openssl rand --base64 16
+
+# credentials for GitHub OAuth
+CMS_GITHUB_CLIENT_ID=${envBuilderOpts.githubOAuth?.clientId}
+CMS_GITHUB_CLIENT_SECRET=${envBuilderOpts.githubOAuth?.clientSecret}
+CMS_GITHUB_REDIRECT_URI=${envBuilderOpts.githubOAuth?.redirectUri}/studiocms_api/auth/github/callback
+
+# credentials for Discord OAuth
+CMS_DISCORD_CLIENT_ID=${envBuilderOpts.discordOAuth?.clientId}
+CMS_DISCORD_CLIENT_SECRET=${envBuilderOpts.discordOAuth?.clientSecret}
+CMS_DISCORD_REDIRECT_URI=${envBuilderOpts.discordOAuth?.redirectUri}/studiocms_api/auth/discord/callback
+
+# credentials for Google OAuth
+CMS_GOOGLE_CLIENT_ID=${envBuilderOpts.googleOAuth?.clientId}
+CMS_GOOGLE_CLIENT_SECRET=${envBuilderOpts.googleOAuth?.clientSecret}
+CMS_GOOGLE_REDIRECT_URI=${envBuilderOpts.googleOAuth?.redirectUri}/studiocms_api/auth/google/callback
+
+# credentials for auth0 OAuth
+CMS_AUTH0_CLIENT_ID=${envBuilderOpts.auth0OAuth?.clientId}
+CMS_AUTH0_CLIENT_SECRET=${envBuilderOpts.auth0OAuth?.clientSecret}
+CMS_AUTH0_DOMAIN=${envBuilderOpts.auth0OAuth?.domain}
+CMS_AUTH0_REDIRECT_URI=${envBuilderOpts.auth0OAuth?.redirectUri}/studiocms_api/auth/auth0/callback
+
+## Cloudinary Javascript SDK
+CMS_CLOUDINARY_CLOUDNAME="demo"
+`;
+}
+export {
+  ExampleEnv,
+  buildEnvFile
+};

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

@@ -0,0 +1,21 @@
+import type { Context } from '../../../lib/context.js';
+interface GenericOAuth {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+}
+interface Auth0OAuth extends GenericOAuth {
+    domain: string;
+}
+export interface EnvBuilderOptions {
+    astroDbRemoteUrl?: string;
+    astroDbToken?: string;
+    encryptionKey?: string;
+    oAuthOptions?: ('github' | 'discord' | 'google' | 'auth0')[];
+    githubOAuth?: GenericOAuth;
+    discordOAuth?: GenericOAuth;
+    googleOAuth?: GenericOAuth;
+    auth0OAuth?: Auth0OAuth;
+}
+export declare function env(ctx: Pick<Context, 'cwd' | 'p' | 'pCancel' | 'pOnCancel' | 'dryRun' | 'tasks' | 'exit' | 'debug' | 'logger'>): Promise<void>;
+export {};

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();