@tutorialkit-rb/cli 0.1.4

package/dist/index.js

@@ -0,0 +1,1364 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import chalk9 from "chalk";
+import yargs2 from "yargs-parser";
+
+// src/commands/create/index.ts
+import fs7 from "node:fs";
+import path8 from "node:path";
+import * as prompts7 from "@clack/prompts";
+import chalk7 from "chalk";
+import "yargs-parser";
+
+// package.json
+var package_default = {
+  name: "@tutorialkit-rb/cli",
+  version: "0.1.4",
+  description: "Interactive tutorials powered by WebContainer API",
+  author: "StackBlitz Inc.",
+  type: "module",
+  bugs: "https://github.com/Bakaface/tutorialkit.rb/issues",
+  homepage: "https://github.com/Bakaface/tutorialkit.rb",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Bakaface/tutorialkit.rb.git",
+    directory: "packages/cli"
+  },
+  bin: {
+    tutorialkit: "dist/index.js"
+  },
+  main: "./dist/index.js",
+  exports: {
+    ".": "./dist/index.js"
+  },
+  scripts: {
+    build: "node scripts/build.js",
+    "build-release": "node scripts/build-release.js",
+    test: "vitest --testTimeout=300000"
+  },
+  files: [
+    "dist",
+    "template",
+    "template/.gitignore"
+  ],
+  dependencies: {
+    "@babel/generator": "7.24.5",
+    "@babel/parser": "7.24.5",
+    "@babel/traverse": "7.24.5",
+    "@babel/types": "7.24.5",
+    "@clack/prompts": "^0.7.0",
+    chalk: "^5.3.0",
+    "detect-indent": "7.0.1",
+    execa: "^9.2.0",
+    ignore: "^5.3.1",
+    lookpath: "^1.2.2",
+    "which-pm": "2.2.0",
+    "yargs-parser": "^21.1.1"
+  },
+  devDependencies: {
+    "@types/babel__generator": "7.6.8",
+    "@types/babel__traverse": "7.20.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.14.6",
+    "@types/yargs-parser": "^21.0.3",
+    esbuild: "^0.20.2",
+    "esbuild-node-externals": "^1.13.1",
+    "fs-extra": "^11.2.0",
+    tempy: "^3.1.0",
+    vitest: "^3.0.5"
+  },
+  engines: {
+    node: ">=18.18.0"
+  }
+};
+
+// src/utils/messages.ts
+import chalk2 from "chalk";
+
+// src/utils/colors.ts
+import chalk from "chalk";
+var primaryBlue = chalk.bgHex("#0d6fe8");
+
+// src/utils/messages.ts
+function primaryLabel(text2) {
+  return primaryBlue(` ${chalk2.whiteBright(text2)} `);
+}
+function errorLabel(text2) {
+  return chalk2.bgRed(` ${chalk2.white(text2 ?? "ERROR")} `);
+}
+function warnLabel(text2) {
+  return chalk2.bgYellow(` ${chalk2.black(text2 ?? "WARN")} `);
+}
+function printHelp({ commandName, usage, tables, prolog, epilog }) {
+  const helpMessage = [];
+  let printNewline = false;
+  if (prolog) {
+    helpMessage.push(prolog);
+    printNewline = true;
+  }
+  if (usage) {
+    if (printNewline) {
+      helpMessage.push("");
+    }
+    printNewline = true;
+    const _usage = Array.isArray(usage) ? usage : [usage];
+    const label = "Usage:";
+    const indentation = " ".repeat(label.length + 1);
+    helpMessage.push(`${chalk2.bold.underline(label)} ${chalk2.green(commandName)} ${chalk2.bold(_usage[0])}`);
+    for (const usageLines of _usage.slice(1)) {
+      helpMessage.push(`${indentation}${chalk2.green(commandName)} ${chalk2.bold(usageLines)}`);
+    }
+  }
+  if (tables) {
+    let i = 0;
+    const tableEntries = Object.entries(tables);
+    if (tableEntries.length > 0 && printNewline) {
+      helpMessage.push("");
+      printNewline = true;
+    }
+    for (const [sectionTitle, tableRows] of tableEntries) {
+      const padding = Object.values(tableRows).reduce((maxLength, table) => {
+        const title = table[0];
+        if (title.length > maxLength) {
+          return title.length;
+        }
+        return maxLength;
+      }, 0);
+      helpMessage.push(chalk2.bold.underline(`${sectionTitle}:`));
+      for (const row of tableRows) {
+        const [command, description] = row;
+        helpMessage.push(`  ${command.padEnd(padding, " ")}  ${chalk2.dim(description)}`);
+      }
+      if (i++ < tableEntries.length - 1) {
+        helpMessage.push("");
+      }
+    }
+  }
+  if (epilog) {
+    if (printNewline) {
+      helpMessage.push("");
+    }
+    helpMessage.push(epilog);
+  }
+  console.log(helpMessage.join("\n"));
+}
+
+// src/utils/random.ts
+function randomValueFromArray(array) {
+  return array[Math.floor(array.length * Math.random())];
+}
+
+// src/utils/words.ts
+var adjectives = [
+  "aged",
+  "ancient",
+  "autumn",
+  "billowing",
+  "bitter",
+  "black",
+  "blue",
+  "bold",
+  "broad",
+  "broken",
+  "calm",
+  "cold",
+  "cool",
+  "crimson",
+  "curly",
+  "damp",
+  "dark",
+  "dawn",
+  "delicate",
+  "divine",
+  "dry",
+  "empty",
+  "falling",
+  "fancy",
+  "flat",
+  "floral",
+  "fragrant",
+  "frosty",
+  "gentle",
+  "green",
+  "hidden",
+  "holy",
+  "icy",
+  "jolly",
+  "late",
+  "lingering",
+  "little",
+  "lively",
+  "long",
+  "lucky",
+  "misty",
+  "morning",
+  "muddy",
+  "mute",
+  "nameless",
+  "noisy",
+  "odd",
+  "old",
+  "orange",
+  "patient",
+  "plain",
+  "polished",
+  "proud",
+  "purple",
+  "quiet",
+  "rapid",
+  "raspy",
+  "red",
+  "restless",
+  "rough",
+  "round",
+  "royal",
+  "shiny",
+  "shrill",
+  "shy",
+  "silent",
+  "small",
+  "snowy",
+  "soft",
+  "solitary",
+  "sparkling",
+  "spring",
+  "square",
+  "steep",
+  "still",
+  "summer",
+  "super",
+  "sweet",
+  "throbbing",
+  "tight",
+  "tiny",
+  "twilight",
+  "wandering",
+  "weathered",
+  "white",
+  "wild",
+  "winter",
+  "wispy",
+  "withered",
+  "yellow",
+  "young"
+];
+var nouns = [
+  "art",
+  "band",
+  "bar",
+  "base",
+  "bird",
+  "block",
+  "boat",
+  "bonus",
+  "bread",
+  "breeze",
+  "brook",
+  "bush",
+  "butterfly",
+  "cake",
+  "cell",
+  "cherry",
+  "cloud",
+  "credit",
+  "darkness",
+  "dawn",
+  "dew",
+  "disk",
+  "dream",
+  "dust",
+  "feather",
+  "field",
+  "fire",
+  "firefly",
+  "flower",
+  "fog",
+  "forest",
+  "frog",
+  "frost",
+  "glade",
+  "glitter",
+  "grass",
+  "hall",
+  "hat",
+  "haze",
+  "heart",
+  "hill",
+  "king",
+  "lab",
+  "lake",
+  "leaf",
+  "limit",
+  "math",
+  "meadow",
+  "mode",
+  "moon",
+  "morning",
+  "mountain",
+  "mouse",
+  "mud",
+  "night",
+  "paper",
+  "pine",
+  "poetry",
+  "pond",
+  "queen",
+  "rain",
+  "recipe",
+  "resonance",
+  "rice",
+  "river",
+  "salad",
+  "scene",
+  "sea",
+  "shadow",
+  "shape",
+  "silence",
+  "sky",
+  "smoke",
+  "snow",
+  "snowflake",
+  "sound",
+  "star",
+  "sun",
+  "sun",
+  "sunset",
+  "surf",
+  "term",
+  "thunder",
+  "tooth",
+  "tree",
+  "truth",
+  "union",
+  "unit",
+  "violet",
+  "voice",
+  "water",
+  "waterfall",
+  "wave",
+  "wildflower",
+  "wind",
+  "wood"
+];
+
+// src/utils/project.ts
+function generateProjectName() {
+  const adjective = randomValueFromArray(adjectives);
+  const noun = randomValueFromArray(nouns);
+  return `${adjective}-${noun}`;
+}
+
+// src/utils/tasks.ts
+import * as prompts from "@clack/prompts";
+function assertNotCanceled(value, exitCode = 0) {
+  if (prompts.isCancel(value)) {
+    prompts.cancel("Command aborted");
+    console.log("Until next time!");
+    process.exit(exitCode);
+  }
+}
+async function runTask(task) {
+  if (task.disabled === true) {
+    return;
+  }
+  if (task.dryRun) {
+    prompts.log.warn(task.dryRunMessage ?? `Skipped '${task.title}'`);
+    return;
+  }
+  const spinner2 = prompts.spinner();
+  spinner2.start(task.title);
+  try {
+    const result = await task.task(spinner2.message);
+    spinner2.stop(result || task.title);
+  } catch (error) {
+    spinner2.stop(`${errorLabel()} ${error.message ?? "Task failed"}`, 1);
+  }
+}
+
+// src/utils/workspace-version.ts
+function updateWorkspaceVersions(dependencies, version, filterDependency = allowAll) {
+  for (const dependency in dependencies) {
+    const depVersion = dependencies[dependency];
+    if (depVersion === "workspace:*" && filterDependency(dependency)) {
+      dependencies[dependency] = version;
+    }
+  }
+}
+function allowAll() {
+  return true;
+}
+
+// src/commands/create/enterprise.ts
+import fs2 from "node:fs";
+import path from "node:path";
+
+// src/utils/astro-config.ts
+import fs from "node:fs/promises";
+
+// src/utils/babel.ts
+import generator from "@babel/generator";
+import parser from "@babel/parser";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+var visit = traverse.default;
+function generate(ast) {
+  const astToText = generator.default;
+  const { code } = astToText(ast);
+  return code;
+}
+var parse = (code) => parser.parse(code, { sourceType: "unambiguous", plugins: ["typescript"] });
+
+// src/utils/astro-config.ts
+async function parseAstroConfig(astroConfigPath) {
+  const source = await fs.readFile(astroConfigPath, { encoding: "utf-8" });
+  const result = parse(source);
+  if (!result) {
+    throw new Error("Unknown error parsing astro config");
+  }
+  if (result.errors.length > 0) {
+    throw new Error("Error parsing astro config: " + JSON.stringify(result.errors));
+  }
+  return result;
+}
+function generateAstroConfig(astroConfig) {
+  const defaultExport = "export default defineConfig";
+  let output = generate(astroConfig);
+  output = output.replace(defaultExport, `
+${defaultExport}`);
+  return output;
+}
+function replaceArgs(newTutorialKitArgs, ast) {
+  const integrationImport = "@tutorialkit-rb/astro";
+  let integrationId;
+  visit(ast, {
+    ImportDeclaration(path10) {
+      if (path10.node.source.value === integrationImport) {
+        const defaultImport = path10.node.specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+        if (defaultImport) {
+          integrationId = defaultImport.local;
+        }
+      }
+    }
+  });
+  if (!integrationId) {
+    throw new Error(`Could not find import to '${integrationImport}'`);
+  }
+  visit(ast, {
+    ExportDefaultDeclaration(path10) {
+      if (!t.isCallExpression(path10.node.declaration)) {
+        return;
+      }
+      const configObject = path10.node.declaration.arguments[0];
+      if (!t.isObjectExpression(configObject)) {
+        throw new Error("TutorialKit is not part of the exported config");
+      }
+      const integrationsProp = configObject.properties.find((prop) => {
+        if (prop.type !== "ObjectProperty") {
+          return false;
+        }
+        if (prop.key.type === "Identifier") {
+          if (prop.key.name === "integrations") {
+            return true;
+          }
+        }
+        if (prop.key.type === "StringLiteral") {
+          if (prop.key.value === "integrations") {
+            return true;
+          }
+        }
+        return false;
+      });
+      if (integrationsProp.value.type !== "ArrayExpression") {
+        throw new Error("Unable to parse integrations in Astro config");
+      }
+      let integrationCall = integrationsProp.value.elements.find((expr) => {
+        return t.isCallExpression(expr) && t.isIdentifier(expr.callee) && expr.callee.name === integrationId.name;
+      });
+      if (!integrationCall) {
+        integrationCall = t.callExpression(integrationId, []);
+        integrationsProp.value.elements.push(integrationCall);
+      }
+      const integrationArgs = integrationCall.arguments;
+      if (integrationArgs.length === 0) {
+        const objectArgs = fromValue(newTutorialKitArgs);
+        if (objectArgs.properties.length > 0) {
+          integrationArgs.push(objectArgs);
+        }
+        return;
+      }
+      if (!t.isObjectExpression(integrationArgs[0])) {
+        throw new Error("Only updating an existing object literal as the config is supported");
+      }
+      updateObject(newTutorialKitArgs, integrationArgs[0]);
+    }
+  });
+}
+function updateObject(properties, object) {
+  if (typeof properties !== "object") {
+    return;
+  }
+  object ??= t.objectExpression([]);
+  for (const property in properties) {
+    const propertyInObject = object.properties.find((prop) => {
+      return prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === property;
+    });
+    if (!propertyInObject) {
+      object.properties.push(t.objectProperty(t.identifier(property), fromValue(properties[property])));
+    } else {
+      if (typeof properties[property] === "object" && t.isObjectExpression(propertyInObject.value)) {
+        updateObject(properties[property], propertyInObject.value);
+      } else {
+        propertyInObject.value = fromValue(properties[property]);
+      }
+    }
+  }
+}
+function fromValue(value) {
+  if (value == null) {
+    return t.nullLiteral();
+  }
+  if (typeof value === "string") {
+    return t.stringLiteral(value);
+  }
+  if (typeof value === "number") {
+    return t.numericLiteral(value);
+  }
+  if (typeof value === "boolean") {
+    return t.booleanLiteral(value);
+  }
+  if (Array.isArray(value)) {
+    return t.arrayExpression(value.map(fromValue));
+  }
+  return t.objectExpression(
+    Object.keys(value).map((key) => t.objectProperty(t.identifier(key), fromValue(value[key])))
+  );
+}
+
+// src/commands/create/enterprise.ts
+async function setupEnterpriseConfig(dest, flags) {
+  if (!flags.defaults && flags.enterprise === void 0) {
+    return;
+  }
+  let editorOrigin = flags.enterprise;
+  if (editorOrigin) {
+    const error = validateEditorOrigin(editorOrigin);
+    if (error) {
+      throw error;
+    }
+    editorOrigin = new URL(editorOrigin).origin;
+  }
+  const configPath = path.resolve(dest, "astro.config.ts");
+  if (!flags.dryRun && editorOrigin) {
+    const astroConfig = await parseAstroConfig(configPath);
+    replaceArgs(
+      {
+        enterprise: {
+          clientId: "wc_api",
+          editorOrigin,
+          scope: "turbo"
+        }
+      },
+      astroConfig
+    );
+    fs2.writeFileSync(configPath, generateAstroConfig(astroConfig));
+  }
+}
+function validateEditorOrigin(value) {
+  if (!value) {
+    return "Please provide an origin!";
+  }
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return "Please provide an origin starting with http:// or https://";
+    }
+  } catch {
+    return "Please provide a valid origin URL!";
+  }
+}
+
+// src/commands/create/gemfile-editing.ts
+import path3 from "node:path";
+import * as prompts2 from "@clack/prompts";
+import chalk3 from "chalk";
+import { execa } from "execa";
+
+// src/commands/create/options.ts
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var templatePath = path2.resolve(__dirname, "../template");
+var DEFAULT_VALUES = {
+  git: !process.env.CI,
+  install: true,
+  start: true,
+  dryRun: false,
+  force: false,
+  packageManager: "npm",
+  provider: "skip"
+};
+function readFlag(flags, flag) {
+  let value = flags[flag];
+  if (flags.defaults) {
+    value ??= DEFAULT_VALUES[flag];
+  }
+  return value;
+}
+
+// src/commands/create/gemfile-editing.ts
+async function promptGemfileEditing(dest, flags) {
+  if (flags.defaults || flags.dryRun) {
+    return false;
+  }
+  prompts2.log.message(chalk3.bold.underline("Ruby Gems Configuration"));
+  prompts2.log.info(`Your Ruby application's gems are configured in ${chalk3.blue("ruby-wasm/Gemfile")}`);
+  const answer = await prompts2.confirm({
+    message: "Would you like to edit the Gemfile to add additional gems?",
+    initialValue: true
+  });
+  assertNotCanceled(answer);
+  if (answer) {
+    const gemfilePath = path3.resolve(dest, "ruby-wasm/Gemfile");
+    const editor = process.env.EDITOR;
+    if (editor) {
+      prompts2.log.message("");
+      prompts2.log.info(`Opening ${chalk3.blue("ruby-wasm/Gemfile")} in your editor...`);
+      try {
+        await execa(editor, [gemfilePath], { stdio: "inherit" });
+        prompts2.log.success("Great! Your Gemfile has been configured.");
+        return true;
+      } catch (error) {
+        prompts2.log.warn(`Failed to open editor: ${error.message}`);
+        prompts2.log.info("Falling back to manual editing instructions...");
+      }
+    }
+    prompts2.log.message("");
+    prompts2.log.step(`1. Open ${chalk3.blue(gemfilePath)} in your editor`);
+    prompts2.log.step(`2. Add any additional gems you need for your tutorial`);
+    prompts2.log.step(`3. Save the file and return here`);
+    prompts2.log.message("");
+    const ready = await prompts2.confirm({
+      message: "Have you finished editing the Gemfile?",
+      initialValue: true
+    });
+    assertNotCanceled(ready);
+    if (ready) {
+      prompts2.log.success("Great! Your Gemfile has been configured.");
+      return true;
+    }
+  }
+  return false;
+}
+function printRubyNextSteps(dest) {
+  let i = 0;
+  prompts2.log.message(chalk3.bold.underline("Next Steps"));
+  const steps = [
+    [`cd ${dest}`, "Navigate to project"],
+    ["npm run build:wasm", "Build Ruby WebAssembly with your gems"],
+    ["npm run dev", "Start development server"],
+    [, `Head over to ${chalk3.underline("http://localhost:4321")}`]
+  ];
+  for (const [command, text2] of steps) {
+    i++;
+    prompts2.log.step(`${i}. ${command ? `${chalk3.blue(command)} - ` : ""}${text2}`);
+  }
+  prompts2.log.message("");
+  prompts2.log.info("\u{1F4A1} The WASM build step may take several minutes the first time.");
+  prompts2.log.info("\u{1F4A1} Subsequent builds will be faster thanks to caching.");
+}
+
+// src/commands/create/generate-hosting-config.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import * as prompts3 from "@clack/prompts";
+import chalk4 from "chalk";
+
+// src/commands/create/hosting-config/_headers.txt?raw
+var headers_default = "/*\n  Cross-Origin-Embedder-Policy: require-corp\n  Cross-Origin-Opener-Policy: same-origin\n";
+
+// src/commands/create/hosting-config/netlify_toml.txt?raw
+var netlify_toml_default = '[[headers]]\n  for = "/*"\n  [headers.values]\n    Cross-Origin-Embedder-Policy = "require-corp"\n    Cross-Origin-Opener-Policy = "same-origin"\n';
+
+// src/commands/create/hosting-config/vercel.json?raw
+var vercel_default = {
+  headers: [
+    {
+      source: "/(.*)",
+      headers: [
+        {
+          key: "Cross-Origin-Embedder-Policy",
+          value: "require-corp"
+        },
+        {
+          key: "Cross-Origin-Opener-Policy",
+          value: "same-origin"
+        }
+      ]
+    }
+  ]
+};
+
+// src/commands/create/generate-hosting-config.ts
+async function generateHostingConfig(dest, flags) {
+  let provider = readFlag(flags, "provider");
+  if (provider === void 0) {
+    provider = await prompts3.select({
+      message: "Select hosting providers for automatic configuration:",
+      options: [
+        { value: "Vercel", label: "Vercel" },
+        { value: "Netlify", label: "Netlify" },
+        { value: "Cloudflare", label: "Cloudflare" },
+        { value: "skip", label: "Skip hosting configuration" }
+      ],
+      initialValue: DEFAULT_VALUES.provider
+    });
+  }
+  if (typeof provider !== "string") {
+    provider = "skip";
+  }
+  if (!provider || provider === "skip") {
+    prompts3.log.message(
+      `${chalk4.blue("hosting provider config [skip]")} You can configure hosting provider settings manually later.`
+    );
+    return provider;
+  }
+  prompts3.log.info(`${chalk4.blue("Hosting Configuration")} Setting up configuration for ${provider}`);
+  const resolvedDest = path4.resolve(dest);
+  if (!fs3.existsSync(resolvedDest)) {
+    fs3.mkdirSync(resolvedDest, { recursive: true });
+  }
+  let config;
+  let filename;
+  switch (provider.toLowerCase()) {
+    case "vercel": {
+      config = typeof vercel_default === "string" ? vercel_default : JSON.stringify(vercel_default, null, 2);
+      filename = "vercel.json";
+      break;
+    }
+    case "netlify": {
+      config = netlify_toml_default;
+      filename = "netlify.toml";
+      break;
+    }
+    case "cloudflare": {
+      config = headers_default;
+      filename = "_headers";
+      break;
+    }
+  }
+  if (config && filename) {
+    await runTask({
+      title: `Create hosting files for ${provider}`,
+      dryRun: flags.dryRun,
+      dryRunMessage: `${warnLabel("DRY RUN")} Skipped hosting provider config creation`,
+      task: async () => {
+        const filepath = path4.join(resolvedDest, filename);
+        fs3.writeFileSync(filepath, config);
+        return `Added ${filepath}`;
+      }
+    });
+  }
+  return provider;
+}
+
+// src/commands/create/git.ts
+import fs4 from "node:fs";
+import path5 from "node:path";
+import * as prompts4 from "@clack/prompts";
+import chalk5 from "chalk";
+
+// src/utils/shell.ts
+import { spawn } from "node:child_process";
+async function runShellCommand(command, flags, opts = {}) {
+  let child;
+  let stdout = "";
+  let stderr = "";
+  try {
+    child = spawn(command, flags, {
+      cwd: opts.cwd,
+      shell: true,
+      stdio: opts.stdio,
+      timeout: opts.timeout
+    });
+    const done = new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code !== 0) {
+          reject(code);
+          return;
+        }
+        resolve(code);
+      });
+      child.on("error", (code) => {
+        reject(code);
+      });
+    });
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (data) => {
+      stdout += data;
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data;
+    });
+    await done;
+  } catch (error) {
+    throw { stdout, stderr, exitCode: error };
+  }
+  return { stdout, stderr, exitCode: child.exitCode };
+}
+
+// src/commands/create/git.ts
+async function initGitRepo(cwd, flags) {
+  let shouldInitGitRepo = readFlag(flags, "git");
+  if (shouldInitGitRepo === void 0) {
+    const answer = await prompts4.confirm({
+      message: "Initialize a new git repository?",
+      initialValue: DEFAULT_VALUES.git
+    });
+    assertNotCanceled(answer);
+    shouldInitGitRepo = answer;
+  }
+  if (shouldInitGitRepo) {
+    await runTask({
+      title: "Initializing git repository",
+      dryRun: flags.dryRun,
+      dryRunMessage: `${warnLabel("DRY RUN")} Skipped initializing git repository`,
+      task: async () => {
+        const message = await _initGitRepo(cwd);
+        return message ?? "Git repository initialized";
+      }
+    });
+  } else {
+    prompts4.log.message(`${chalk5.blue("git [skip]")} You can always run ${chalk5.yellow("git init")} manually.`);
+  }
+}
+async function _initGitRepo(cwd) {
+  if (fs4.existsSync(path5.join(cwd, ".git"))) {
+    return `${chalk5.cyan("Nice!")} Git has already been initialized`;
+  }
+  try {
+    await runShellCommand("git", ["init"], { cwd, stdio: "ignore" });
+    await runShellCommand("git", ["add", "-A"], { cwd, stdio: "ignore" });
+    await runShellCommand(
+      "git",
+      ["commit", "-m", `"feat: initial commit from ${package_default.name}"`, '--author="StackBlitz <hello@stackblitz.com>"'],
+      {
+        cwd,
+        stdio: "ignore"
+      }
+    );
+    return void 0;
+  } catch {
+    throw new Error("Failed to initialize local git repository");
+  }
+}
+
+// src/commands/create/package-manager.ts
+import fs5 from "node:fs";
+import path6 from "node:path";
+import * as prompts5 from "@clack/prompts";
+import chalk6 from "chalk";
+import { lookpath } from "lookpath";
+var LOCK_FILES = /* @__PURE__ */ new Map([
+  ["npm", "package-lock.json"],
+  ["pnpm", "pnpm-lock.yaml"],
+  ["yarn", "yarn.lock"]
+]);
+async function selectPackageManager(cwd, flags) {
+  const packageManager = await resolvePackageManager(flags);
+  for (const [pkgManager, lockFile] of LOCK_FILES) {
+    if (pkgManager !== packageManager) {
+      fs5.rmSync(path6.join(cwd, lockFile), { force: true });
+    }
+  }
+  return packageManager;
+}
+async function resolvePackageManager(flags) {
+  if (flags.packageManager) {
+    if (await lookpath(String(flags.packageManager))) {
+      return flags.packageManager;
+    }
+    prompts5.log.warn(
+      `The specified package manager '${chalk6.yellow(flags.packageManager)}' doesn't seem to be installed!`
+    );
+  }
+  if (flags.defaults) {
+    return DEFAULT_VALUES.packageManager;
+  }
+  return await getPackageManager();
+}
+async function getPackageManager() {
+  const installedPackageManagers = await getInstalledPackageManagers();
+  let initialValue = process.env.npm_config_user_agent?.split("/")[0];
+  if (!installedPackageManagers.includes(initialValue)) {
+    initialValue = "npm";
+  }
+  const answer = await prompts5.select({
+    message: "What package manager should we use?",
+    initialValue,
+    options: [
+      { label: "npm", value: "npm" },
+      ...installedPackageManagers.map((pkgManager) => {
+        return { label: pkgManager, value: pkgManager };
+      })
+    ]
+  });
+  assertNotCanceled(answer);
+  return answer;
+}
+async function getInstalledPackageManagers() {
+  const packageManagers = [];
+  for (const pkgManager of ["yarn", "pnpm", "bun"]) {
+    try {
+      if (await lookpath(pkgManager)) {
+        packageManagers.push(pkgManager);
+      }
+    } catch {
+    }
+  }
+  return packageManagers;
+}
+
+// src/commands/create/template.ts
+import fs6 from "node:fs";
+import fsPromises from "node:fs/promises";
+import path7 from "node:path";
+import * as prompts6 from "@clack/prompts";
+import ignore from "ignore";
+async function copyTemplate(dest, flags) {
+  if (flags.dryRun) {
+    prompts6.log.warn(`${warnLabel("DRY RUN")} Skipped copying template`);
+    return;
+  }
+  const gitignore = ignore.default().add(readIgnoreFile());
+  const toCopy = [];
+  const folders = await fsPromises.readdir(templatePath);
+  for (const file of folders) {
+    if (gitignore.ignores(file)) {
+      continue;
+    }
+    toCopy.push(file);
+  }
+  for (const fileName of toCopy) {
+    const sourceFilePath = path7.join(templatePath, fileName);
+    const destFileName = fileName === ".npmignore" ? ".gitignore" : fileName;
+    const destFilePath = path7.join(dest, destFileName);
+    const stats = await fsPromises.stat(sourceFilePath);
+    if (stats.isDirectory()) {
+      await fsPromises.cp(sourceFilePath, destFilePath, { recursive: true });
+    } else if (stats.isFile()) {
+      await fsPromises.copyFile(sourceFilePath, destFilePath);
+    }
+  }
+}
+function readIgnoreFile() {
+  try {
+    return fs6.readFileSync(path7.resolve(templatePath, ".npmignore"), "utf8");
+  } catch {
+    return fs6.readFileSync(path7.resolve(templatePath, ".gitignore"), "utf8");
+  }
+}
+
+// src/commands/create/index.ts
+var TUTORIALKIT_VERSION = package_default.version;
+async function createTutorial(flags) {
+  if (flags._[1] === "help" || flags.help || flags.h) {
+    printHelp({
+      commandName: `${package_default.name} create`,
+      usage: "[name] [...options]",
+      tables: {
+        Options: [
+          ["--dir, -d", "The folder in which the tutorial gets created"],
+          ["--git, --no-git", `Initialize a local git repository (default ${chalk7.yellow(DEFAULT_VALUES.git)})`],
+          [
+            "--provider <name>, --no-provider",
+            `Select a hosting provider (default ${chalk7.yellow(DEFAULT_VALUES.provider)})`
+          ],
+          ["--dry-run", `Walk through steps without executing (default ${chalk7.yellow(DEFAULT_VALUES.dryRun)})`],
+          [
+            "--package-manager <name>, -p <name>",
+            `The package used to install dependencies (default ${chalk7.yellow(DEFAULT_VALUES.packageManager)})`
+          ],
+          [
+            "--enterprise <origin>, -e <origin>",
+            `The origin of your StackBlitz Enterprise instance (if not provided authentication is not turned on and your project will use ${chalk7.yellow("https://stackblitz.com")})`
+          ],
+          [
+            "--force",
+            `Overwrite existing files in the target directory without prompting (default ${chalk7.yellow(DEFAULT_VALUES.force)})`
+          ],
+          ["--defaults", "Skip all prompts and initialize the tutorial using the defaults"]
+        ]
+      }
+    });
+    return 0;
+  }
+  applyAliases(flags);
+  try {
+    return _createTutorial(flags);
+  } catch (error) {
+    console.error(`${errorLabel()} Command failed`);
+    if (error.stack) {
+      console.error(`
+${error.stack}`);
+    }
+    process.exit(1);
+  }
+}
+async function _createTutorial(flags) {
+  prompts7.intro(primaryLabel(package_default.name));
+  let tutorialName = flags._[1] !== void 0 ? String(flags._[1]) : void 0;
+  if (tutorialName === void 0) {
+    const randomName = generateProjectName();
+    if (flags.defaults) {
+      tutorialName = randomName;
+    } else {
+      const answer = await prompts7.text({
+        message: `What's the name of your tutorial?`,
+        placeholder: randomName,
+        validate: (value) => {
+          if (!value) {
+            return "Please provide a name!";
+          }
+          return void 0;
+        }
+      });
+      assertNotCanceled(answer);
+      tutorialName = answer;
+    }
+  }
+  prompts7.log.info(`We'll call your tutorial ${chalk7.blue(tutorialName)}`);
+  const dest = await getTutorialDirectory(tutorialName, flags);
+  const resolvedDest = path8.resolve(process.cwd(), dest);
+  prompts7.log.info(`Scaffolding tutorial in ${chalk7.blue(resolvedDest)}`);
+  if (fs7.existsSync(resolvedDest) && !flags.force) {
+    if (flags.defaults) {
+      console.error(`
+${errorLabel()} Failed to create tutorial. Directory already exists.`);
+      process.exit(1);
+    }
+    let answer;
+    if (fs7.readdirSync(resolvedDest).length > 0) {
+      answer = await prompts7.confirm({
+        message: `Directory is not empty. Continuing may overwrite existing files. Do you want to continue?`,
+        initialValue: false
+      });
+    } else {
+      answer = await prompts7.confirm({
+        message: `Directory already exists. Continuing may overwrite existing files. Do you want to continue?`,
+        initialValue: false
+      });
+    }
+    assertNotCanceled(answer);
+    if (!answer) {
+      exitEarly();
+    }
+  } else {
+    if (!flags.dryRun) {
+      fs7.mkdirSync(resolvedDest, { recursive: true });
+    }
+  }
+  await copyTemplate(resolvedDest, flags);
+  const provider = await generateHostingConfig(resolvedDest, flags);
+  updatePackageJson(resolvedDest, tutorialName, flags, provider);
+  const selectedPackageManager = await selectPackageManager(resolvedDest, flags);
+  updateReadme(resolvedDest, selectedPackageManager, flags);
+  await setupEnterpriseConfig(resolvedDest, flags);
+  await initGitRepo(resolvedDest, flags);
+  prompts7.log.success(chalk7.green("Tutorial successfully created!"));
+  await promptGemfileEditing(dest, flags);
+  printRubyNextSteps(dest);
+  prompts7.outro(`You're all set!`);
+  console.log("Until next time \u{1F44B}");
+}
+async function getTutorialDirectory(tutorialName, flags) {
+  const dir = flags.dir;
+  if (dir) {
+    return dir;
+  }
+  if (flags.defaults) {
+    return `./${tutorialName}`;
+  }
+  const promptResult = await prompts7.text({
+    message: "Where should we create your new tutorial?",
+    initialValue: `./${tutorialName}`,
+    placeholder: "./",
+    validate(value) {
+      if (!path8.isAbsolute(value) && !value.startsWith("./")) {
+        return "Please provide an absolute or relative path!";
+      }
+      return void 0;
+    }
+  });
+  assertNotCanceled(promptResult);
+  return promptResult;
+}
+function updatePackageJson(dest, projectName, flags, provider) {
+  if (flags.dryRun) {
+    return;
+  }
+  const pkgPath = path8.resolve(dest, "package.json");
+  const pkgJson = JSON.parse(fs7.readFileSync(pkgPath, "utf8"));
+  pkgJson.name = projectName;
+  updateWorkspaceVersions(pkgJson.dependencies, TUTORIALKIT_VERSION);
+  updateWorkspaceVersions(pkgJson.devDependencies, TUTORIALKIT_VERSION);
+  if (provider.toLowerCase() === "cloudflare") {
+    pkgJson.scripts = pkgJson.scripts || {};
+    pkgJson.scripts.postbuild = "cp _headers ./dist/";
+  }
+  fs7.writeFileSync(pkgPath, JSON.stringify(pkgJson, null, 2));
+  try {
+    const pkgLockPath = path8.resolve(dest, "package-lock.json");
+    const pkgLockJson = JSON.parse(fs7.readFileSync(pkgLockPath, "utf8"));
+    const defaultPackage = pkgLockJson.packages[""];
+    pkgLockJson.name = projectName;
+    if (defaultPackage) {
+      defaultPackage.name = projectName;
+    }
+    fs7.writeFileSync(pkgLockPath, JSON.stringify(pkgLockJson, null, 2));
+  } catch {
+  }
+}
+function updateReadme(dest, packageManager, flags) {
+  if (flags.dryRun) {
+    return;
+  }
+  const readmePath = path8.resolve(dest, "README.md");
+  let readme = fs7.readFileSync(readmePath, "utf8");
+  readme = readme.replaceAll("<% pkgManager %>", packageManager ?? DEFAULT_VALUES.packageManager);
+  fs7.writeFileSync(readmePath, readme);
+}
+function exitEarly(exitCode = 0) {
+  prompts7.outro("Until next time!");
+  process.exit(exitCode);
+}
+function applyAliases(flags) {
+  if (flags.d) {
+    flags.dir = flags.d;
+  }
+  if (flags.p) {
+    flags.packageManager = flags.p;
+  }
+  if (flags.e) {
+    flags.enterprise = flags.e;
+  }
+}
+
+// src/commands/eject/index.ts
+import fs8 from "node:fs";
+import path9 from "node:path";
+import * as prompts8 from "@clack/prompts";
+import chalk8 from "chalk";
+import detectIndent from "detect-indent";
+import { execa as execa2 } from "execa";
+import whichpm from "which-pm";
+
+// src/commands/eject/options.ts
+var DEFAULT_VALUES2 = {
+  force: false,
+  defaults: false
+};
+
+// src/commands/eject/index.ts
+var TUTORIALKIT_VERSION2 = package_default.version;
+var REQUIRED_DEPENDENCIES = [
+  "@tutorialkit-rb/runtime",
+  "@webcontainer/api",
+  "nanostores",
+  "@nanostores/react",
+  "kleur",
+  "@stackblitz/sdk",
+  "fast-glob"
+];
+function ejectRoutes(flags) {
+  if (flags._[1] === "help" || flags.help || flags.h) {
+    printHelp({
+      commandName: `${package_default.name} eject`,
+      usage: "[folder] [...options]",
+      tables: {
+        Options: [
+          [
+            "--force",
+            `Overwrite existing files in the target directory without prompting (default ${chalk8.yellow(DEFAULT_VALUES2.force)})`
+          ],
+          ["--defaults", "Skip all the prompts and eject the routes using the defaults"]
+        ]
+      }
+    });
+    return 0;
+  }
+  try {
+    return _eject(flags);
+  } catch (error) {
+    console.error(`${errorLabel()} Command failed`);
+    if (error.stack) {
+      console.error(`
+${error.stack}`);
+    }
+    process.exit(1);
+  }
+}
+async function _eject(flags) {
+  let folderPath = flags._[1] !== void 0 ? String(flags._[1]) : void 0;
+  if (folderPath === void 0) {
+    folderPath = process.cwd();
+  } else {
+    folderPath = path9.resolve(process.cwd(), folderPath);
+  }
+  const { astroConfigPath, srcPath, pkgJsonPath, astroIntegrationPath, srcDestPath } = validateDestination(
+    folderPath,
+    flags.force
+  );
+  const astroConfig = await parseAstroConfig(astroConfigPath);
+  replaceArgs({ defaultRoutes: false }, astroConfig);
+  fs8.writeFileSync(astroConfigPath, generateAstroConfig(astroConfig));
+  fs8.cpSync(srcPath, srcDestPath, { recursive: true });
+  const pkgJsonContent = fs8.readFileSync(pkgJsonPath, "utf-8");
+  const indent = detectIndent(pkgJsonContent).indent || "  ";
+  const pkgJson = JSON.parse(pkgJsonContent);
+  const astroIntegrationPkgJson = JSON.parse(
+    fs8.readFileSync(path9.join(astroIntegrationPath, "package.json"), "utf-8")
+  );
+  const newDependencies = [];
+  for (const dep of REQUIRED_DEPENDENCIES) {
+    if (!(dep in pkgJson.dependencies) && !(dep in pkgJson.devDependencies)) {
+      pkgJson.dependencies[dep] = astroIntegrationPkgJson.dependencies[dep];
+      newDependencies.push(dep);
+    }
+  }
+  updateWorkspaceVersions(
+    pkgJson.dependencies,
+    TUTORIALKIT_VERSION2,
+    (dependency) => REQUIRED_DEPENDENCIES.includes(dependency)
+  );
+  if (newDependencies.length > 0) {
+    fs8.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, void 0, indent), { encoding: "utf-8" });
+    console.log(
+      primaryLabel("INFO"),
+      `New dependencies added: ${newDependencies.join(", ")}. Install the new dependencies before proceeding.`
+    );
+    if (!flags.defaults) {
+      const packageManager = (await whichpm(path9.dirname(pkgJsonPath))).name;
+      const answer = await prompts8.confirm({
+        message: `Do you want to install those dependencies now using ${chalk8.blue(packageManager)}?`
+      });
+      if (answer === true) {
+        await execa2(packageManager, ["install"], { cwd: folderPath, stdio: "inherit" });
+      }
+    }
+  }
+  return 0;
+}
+function validateDestination(folder, force) {
+  assertExists(folder);
+  const pkgJsonPath = assertExists(path9.join(folder, "package.json"));
+  const astroConfigPath = assertExists(path9.join(folder, "astro.config.ts"));
+  const srcDestPath = assertExists(path9.join(folder, "src"));
+  const astroIntegrationPath = assertExists(path9.resolve(folder, "node_modules", "@tutorialkit-rb", "astro"));
+  const srcPath = path9.join(astroIntegrationPath, "dist", "default");
+  if (!force) {
+    walk(srcPath, (relativePath) => {
+      const destination = path9.join(srcDestPath, relativePath);
+      if (fs8.existsSync(destination)) {
+        throw new Error(
+          `Eject aborted because '${destination}' would be overwritten by this command. Use ${chalk8.yellow("--force")} to ignore this error.`
+        );
+      }
+    });
+  }
+  return {
+    astroConfigPath,
+    astroIntegrationPath,
+    pkgJsonPath,
+    srcPath,
+    srcDestPath
+  };
+}
+function assertExists(filePath) {
+  if (!fs8.existsSync(filePath)) {
+    throw new Error(`${filePath} does not exists!`);
+  }
+  return filePath;
+}
+function walk(root, visit2) {
+  function traverse2(folder, pathPrefix) {
+    for (const filename of fs8.readdirSync(folder)) {
+      const filePath = path9.join(folder, filename);
+      const stat = fs8.statSync(filePath);
+      const relativeFilePath = path9.join(pathPrefix, filename);
+      if (stat.isDirectory()) {
+        traverse2(filePath, relativeFilePath);
+      } else {
+        visit2(relativeFilePath);
+      }
+    }
+  }
+  traverse2(root, "");
+}
+
+// src/index.ts
+var supportedCommands = /* @__PURE__ */ new Set(["version", "help", "create", "eject"]);
+cli();
+async function cli() {
+  const flags = yargs2(process.argv.slice(2));
+  const cmd = resolveCommand(flags);
+  try {
+    console.log("");
+    const exitCode = await runCommand(cmd, flags);
+    process.exit(exitCode || 0);
+  } catch (error) {
+    console.error(`${errorLabel()} ${error.message}`);
+    process.exit(1);
+  }
+}
+async function runCommand(cmd, flags) {
+  switch (cmd) {
+    case "version": {
+      console.log(`${primaryLabel(package_default.name)} ${chalk9.green(`v${package_default.version}`)}`);
+      return;
+    }
+    case "help": {
+      printHelp({
+        commandName: package_default.name,
+        prolog: `${primaryLabel(package_default.name)} ${chalk9.green(`v${package_default.version}`)} Create tutorial apps powered by WebContainer API`,
+        usage: ["[command] [...options]", "[ -h | --help | -v | --version ]"],
+        tables: {
+          Commands: [
+            ["create", "Create new tutorial app"],
+            [
+              "eject",
+              "Move all default pages and components into your project, providing full control over the Astro app"
+            ],
+            ["help", "Show this help message"]
+          ]
+        }
+      });
+      return;
+    }
+    case "create": {
+      return createTutorial(flags);
+    }
+    case "eject": {
+      return ejectRoutes(flags);
+    }
+    default: {
+      console.error(`${errorLabel()} Unknown command ${chalk9.red(cmd)}`);
+      return 1;
+    }
+  }
+}
+function resolveCommand(flags) {
+  if (flags.version || flags.v) {
+    return "version";
+  }
+  if (flags._[0] == null && (flags.help || flags.h)) {
+    return "help";
+  }
+  const cmd = String(flags._.at(0));
+  if (!supportedCommands.has(cmd)) {
+    return "help";
+  }
+  return cmd;
+}