web-extension 0.0.0-stage → 2.0.0

package/dist/index.js

@@ -0,0 +1,2125 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as p2 from "@clack/prompts";
+import pico from "picocolors";
+import fs6 from "fs";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/utils/validate.ts
+import path from "path";
+function validatePackageName(name) {
+  if (!name || name.trim().length === 0) {
+    return "Project name cannot be empty.";
+  }
+  const trimmed = name.trim();
+  if (trimmed !== trimmed.toLowerCase()) {
+    return "Project name must be lowercase.";
+  }
+  if (/\s/.test(trimmed)) {
+    return "Project name cannot contain spaces.";
+  }
+  if (trimmed.startsWith(".") || trimmed.startsWith("_")) {
+    return "Project name cannot start with a dot or underscore.";
+  }
+  if (!/^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(trimmed)) {
+    return "Project name contains invalid characters for an npm package.";
+  }
+  if (encodeURIComponent(trimmed) !== trimmed && !trimmed.startsWith("@")) {
+    return "Project name must be URL-safe.";
+  }
+  return true;
+}
+function getPackageName(input) {
+  const base = path.basename(path.resolve(input));
+  return base.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/^-+|-+$/g, "") || "my-extension";
+}
+function validateMatchPattern(pattern) {
+  const p3 = pattern.trim();
+  if (!p3) {
+    return "Match pattern cannot be empty.";
+  }
+  if (p3 === "<all_urls>") {
+    return true;
+  }
+  const validSchemes = ["http://", "https://", "*://", "file://"];
+  const hasValidScheme = validSchemes.some((scheme) => p3.startsWith(scheme));
+  if (!hasValidScheme) {
+    return `Invalid match pattern "${p3}". Must start with http://, https://, *://, file://, or be <all_urls>`;
+  }
+  return true;
+}
+function parseAndValidateMatches(input) {
+  const list = Array.isArray(input) ? input : input.split(",").map((s) => s.trim()).filter(Boolean);
+  if (list.length === 0) {
+    return { valid: false, error: "At least one match pattern is required." };
+  }
+  for (const item of list) {
+    const res = validateMatchPattern(item);
+    if (res !== true) {
+      return { valid: false, error: res };
+    }
+  }
+  return { valid: true, matches: list };
+}
+function toSlug(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "extension";
+}
+
+// src/cli/args.ts
+var VALID_BROWSERS = ["chrome", "firefox", "safari", "chromium"];
+var VALID_LANGS = ["ts", "js", "typescript", "javascript"];
+var VALID_TYPES = ["full", "content-only"];
+var VALID_MVS = ["2", "3"];
+var VALID_FEATURES = [
+  "background",
+  "content",
+  "popup",
+  "options",
+  "sidepanel",
+  "dnr",
+  "devtools",
+  "newtab"
+];
+var VALID_EXTRAS = [
+  "contextmenu",
+  "commands",
+  "omnibox",
+  "storage"
+];
+var VALID_RUN_AT = [
+  "document_start",
+  "document_end",
+  "document_idle"
+];
+var VALID_WORLD = ["ISOLATED", "MAIN"];
+var VALID_IF_EXISTS = ["cancel", "overwrite", "merge"];
+var VALID_PM = ["npm", "pnpm", "yarn", "bun"];
+function parseCliArgs(argv) {
+  const result = {
+    rawFlags: {},
+    warnings: []
+  };
+  const positionals = [];
+  const browserList = [];
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+      i++;
+    } else if (arg === "--version" || arg === "-v") {
+      result.version = true;
+      i++;
+    } else if (arg === "--yes" || arg === "-y") {
+      result.yes = true;
+      i++;
+    } else if (arg === "--overwrite") {
+      result.ifExists = "overwrite";
+      result.rawFlags["ifExists"] = "overwrite";
+      i++;
+    } else if (arg === "--css") {
+      result.css = true;
+      result.rawFlags["css"] = true;
+      i++;
+    } else if (arg === "--no-css") {
+      result.css = false;
+      result.rawFlags["css"] = false;
+      i++;
+    } else if (arg === "--install") {
+      result.install = true;
+      result.rawFlags["install"] = true;
+      i++;
+    } else if (arg === "--no-install") {
+      result.install = false;
+      result.rawFlags["install"] = false;
+      i++;
+    } else if (arg === "--git") {
+      result.git = true;
+      result.rawFlags["git"] = true;
+      i++;
+    } else if (arg === "--no-git") {
+      result.git = false;
+      result.rawFlags["git"] = false;
+      i++;
+    } else if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      let flag = arg.slice(2);
+      let val;
+      if (eqIdx !== -1) {
+        flag = arg.slice(2, eqIdx);
+        val = arg.slice(eqIdx + 1);
+      } else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        val = argv[++i];
+      }
+      if (val === void 0) {
+        throw new Error(`Flag --${flag} requires a value.`);
+      }
+      switch (flag) {
+        case "name":
+          result.name = val;
+          result.rawFlags["name"] = val;
+          break;
+        case "if-exists":
+          if (!VALID_IF_EXISTS.includes(val)) {
+            throw new Error(
+              `Invalid value "${val}" for --if-exists. Expected one of: ${VALID_IF_EXISTS.join(", ")}`
+            );
+          }
+          result.ifExists = val;
+          result.rawFlags["ifExists"] = val;
+          break;
+        case "lang":
+          if (!VALID_LANGS.includes(val.toLowerCase())) {
+            throw new Error(
+              `Invalid value "${val}" for --lang. Expected one of: ts, js`
+            );
+          }
+          result.lang = val.toLowerCase() === "javascript" || val.toLowerCase() === "js" ? "js" : "ts";
+          result.rawFlags["lang"] = result.lang;
+          break;
+        case "type":
+          if (!VALID_TYPES.includes(val.toLowerCase())) {
+            throw new Error(
+              `Invalid value "${val}" for --type. Expected one of: ${VALID_TYPES.join(", ")}`
+            );
+          }
+          result.type = val.toLowerCase();
+          result.rawFlags["type"] = result.type;
+          break;
+        case "browser":
+        case "browsers": {
+          const parts = val.split(",").map((s) => s.trim().toLowerCase());
+          for (const b of parts) {
+            if (!VALID_BROWSERS.includes(b)) {
+              throw new Error(
+                `Invalid value "${b}" for --browser. Expected one of: chrome, firefox, safari`
+              );
+            }
+            const mapped = b === "chromium" ? "chrome" : b;
+            if (!browserList.includes(mapped)) {
+              browserList.push(mapped);
+            }
+          }
+          result.browser = browserList;
+          result.rawFlags["browser"] = browserList;
+          break;
+        }
+        case "firefox-mv":
+          if (!VALID_MVS.includes(val)) {
+            throw new Error(
+              `Invalid value "${val}" for --firefox-mv. Expected 2 or 3.`
+            );
+          }
+          result.firefoxMv = parseInt(val, 10);
+          result.rawFlags["firefoxMv"] = result.firefoxMv;
+          break;
+        case "safari-mv":
+          if (!VALID_MVS.includes(val)) {
+            throw new Error(
+              `Invalid value "${val}" for --safari-mv. Expected 2 or 3.`
+            );
+          }
+          result.safariMv = parseInt(val, 10);
+          result.rawFlags["safariMv"] = result.safariMv;
+          break;
+        case "features": {
+          if (val.trim().toLowerCase() === "none") {
+            result.features = [];
+          } else {
+            const list = val.split(",").map((s) => s.trim().toLowerCase());
+            for (const f of list) {
+              if (!VALID_FEATURES.includes(f)) {
+                throw new Error(
+                  `Invalid feature "${f}". Expected one of: ${VALID_FEATURES.join(", ")} (or none)`
+                );
+              }
+            }
+            result.features = Array.from(new Set(list));
+          }
+          result.rawFlags["features"] = result.features;
+          break;
+        }
+        case "matches": {
+          const matchRes = parseAndValidateMatches(val);
+          if (!matchRes.valid) {
+            throw new Error(matchRes.error);
+          }
+          result.matches = matchRes.matches;
+          result.rawFlags["matches"] = result.matches;
+          break;
+        }
+        case "run-at":
+          if (!VALID_RUN_AT.includes(val)) {
+            throw new Error(
+              `Invalid value "${val}" for --run-at. Expected one of: ${VALID_RUN_AT.join(", ")}`
+            );
+          }
+          result.runAt = val;
+          result.rawFlags["runAt"] = result.runAt;
+          break;
+        case "world":
+          if (!VALID_WORLD.includes(val.toUpperCase())) {
+            throw new Error(
+              `Invalid value "${val}" for --world. Expected ISOLATED or MAIN`
+            );
+          }
+          result.world = val.toUpperCase();
+          result.rawFlags["world"] = result.world;
+          break;
+        case "extras": {
+          if (val.trim().toLowerCase() === "none") {
+            result.extras = [];
+          } else {
+            const list = val.split(",").map((s) => s.trim().toLowerCase());
+            for (const e of list) {
+              if (!VALID_EXTRAS.includes(e)) {
+                throw new Error(
+                  `Invalid extra "${e}". Expected one of: ${VALID_EXTRAS.join(", ")} (or none)`
+                );
+              }
+            }
+            result.extras = Array.from(new Set(list));
+          }
+          result.rawFlags["extras"] = result.extras;
+          break;
+        }
+        case "pm":
+          if (!VALID_PM.includes(val.toLowerCase())) {
+            throw new Error(
+              `Invalid value "${val}" for --pm. Expected one of: ${VALID_PM.join(", ")}`
+            );
+          }
+          result.pm = val.toLowerCase();
+          result.rawFlags["pm"] = result.pm;
+          break;
+        default:
+          throw new Error(`Unknown option --${flag}. Run with --help to see valid options.`);
+      }
+      i++;
+    } else {
+      positionals.push(arg);
+      i++;
+    }
+  }
+  if (positionals.length > 0) {
+    if (positionals[0] === "init") {
+      result.subcommand = "init";
+      if (positionals.length > 1) {
+        result.dir = positionals[1];
+      }
+    } else {
+      result.subcommand = "init";
+      result.dir = positionals[0];
+    }
+  } else {
+    result.subcommand = "init";
+  }
+  return result;
+}
+function validateFlagCombinations(args) {
+  if (args.help || args.version) {
+    return;
+  }
+  const isContentOnly = args.type === "content-only";
+  if (isContentOnly && (args.features !== void 0 || args.extras !== void 0)) {
+    throw new Error(
+      "Cannot specify --features or --extras when --type is content-only."
+    );
+  }
+  const browsers = args.browser || ["chrome"];
+  const hasOnlySafari = browsers.length === 1 && browsers[0] === "safari";
+  if (args.features?.includes("sidepanel") && hasOnlySafari) {
+    throw new Error("Side panel feature is not supported when targeting only Safari.");
+  }
+  const hasFirefoxMv2 = browsers.includes("firefox") && args.firefoxMv === 2;
+  const hasSafariMv2 = browsers.includes("safari") && args.safariMv === 2;
+  const anyMv2 = hasFirefoxMv2 || hasSafariMv2;
+  if (args.features?.includes("dnr") && anyMv2) {
+    throw new Error(
+      "DeclarativeNetRequest (DNR) is not supported with Manifest V2 targets."
+    );
+  }
+  const hasBackground = !isContentOnly && (args.features === void 0 || args.features.includes("background"));
+  if (args.extras?.some((e) => ["contextmenu", "commands", "omnibox"].includes(e))) {
+    if (!hasBackground) {
+      throw new Error(
+        "Extras contextmenu, commands, and omnibox require background feature."
+      );
+    }
+  }
+  if (args.world === "MAIN" && anyMv2) {
+    throw new Error("Content script world MAIN is only supported in Manifest V3.");
+  }
+  if (args.firefoxMv !== void 0 && !browsers.includes("firefox")) {
+    args.warnings.push("--firefox-mv specified without Firefox target.");
+  }
+  if (args.safariMv !== void 0 && !browsers.includes("safari")) {
+    args.warnings.push("--safari-mv specified without Safari target.");
+  }
+  if (!isContentOnly && args.features !== void 0 && !args.features.includes("content")) {
+    if (args.matches !== void 0 || args.runAt !== void 0 || args.world !== void 0 || args.css !== void 0) {
+      args.warnings.push("Content script options specified but content feature was not selected.");
+    }
+  }
+}
+function printHelp() {
+  console.log(`
+web-extension [init] [dir] [options]
+
+Options:
+  [dir]                  Target directory (defaults to current or prompt)
+  --name <string>        Project name (defaults to basename of dir or "my-extension")
+  --if-exists <action>   Action if directory exists: cancel, overwrite, merge (default: cancel)
+  --overwrite            Shorthand for --if-exists overwrite
+  --lang <ts|js>         Project language: ts (TypeScript) or js (JavaScript) (default: ts)
+  --type <type>          Project type: full or content-only (default: full)
+  --browser <browsers>   Target browsers: chrome, firefox, safari (default: chrome)
+  --firefox-mv <2|3>     Manifest version for Firefox (default: 3)
+  --safari-mv <2|3>      Manifest version for Safari (default: 3)
+  --features <list>      Comma-separated features: background,content,popup,options,sidepanel,dnr,devtools,newtab (or "none")
+  --matches <patterns>   Content script match patterns (default: https://*/*)
+  --run-at <timing>      Content script run timing: document_start, document_end, document_idle (default: document_idle)
+  --world <world>        Execution world: ISOLATED or MAIN (default: ISOLATED)
+  --css / --no-css       Generate CSS for content script (default: --css)
+  --extras <list>        Extras: contextmenu,commands,omnibox,storage (or "none")
+  --pm <pm>              Package manager override: npm, pnpm, yarn, bun
+  --install / --no-install  Install dependencies automatically (default: --install)
+  --git / --no-git       Initialize git repository (default: --git)
+  --yes, -y              Use defaults for all unanswered questions
+  --help, -h             Show this help message
+  --version, -v          Show version number
+`);
+}
+
+// src/cli/prompts.ts
+import * as p from "@clack/prompts";
+import fs3 from "fs";
+import path4 from "path";
+
+// src/utils/pm.ts
+import fs from "fs";
+import path2 from "path";
+function detectPackageManager(input = {}) {
+  const fsImpl = input.fsModule ?? {
+    existsSync: fs.existsSync,
+    readFileSync: (p3) => fs.readFileSync(p3, "utf-8"),
+    realpathSync: fs.realpathSync
+  };
+  const env = input.env ?? process.env;
+  const argv1 = input.argv1 ?? process.argv[1];
+  const versions = input.versions ?? process.versions;
+  if (input.flag) {
+    const f = input.flag.trim().toLowerCase();
+    if (f === "npm" || f === "pnpm" || f === "yarn" || f === "bun") {
+      return { name: f, source: "flag", confident: true };
+    }
+  }
+  const userAgent = env.npm_config_user_agent;
+  if (userAgent) {
+    const ua = userAgent.trim().toLowerCase();
+    if (ua.startsWith("bun/")) {
+      return { name: "bun", source: "user-agent", confident: true };
+    }
+    if (ua.startsWith("pnpm/")) {
+      return { name: "pnpm", source: "user-agent", confident: true };
+    }
+    if (ua.startsWith("yarn/")) {
+      return { name: "yarn", source: "user-agent", confident: true };
+    }
+    if (ua.startsWith("npm/")) {
+      return { name: "npm", source: "user-agent", confident: true };
+    }
+  }
+  const startDir = path2.resolve(input.targetDir || input.cwd || process.cwd());
+  let curDir = startDir;
+  while (true) {
+    const pkgPath = path2.join(curDir, "package.json");
+    if (fsImpl.existsSync(pkgPath)) {
+      try {
+        const raw = fsImpl.readFileSync(pkgPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.packageManager === "string") {
+          const pmField = parsed.packageManager.toLowerCase();
+          if (pmField.startsWith("bun@") || pmField === "bun") {
+            return { name: "bun", source: "package-json", confident: true };
+          }
+          if (pmField.startsWith("pnpm@") || pmField === "pnpm") {
+            return { name: "pnpm", source: "package-json", confident: true };
+          }
+          if (pmField.startsWith("yarn@") || pmField === "yarn") {
+            return { name: "yarn", source: "package-json", confident: true };
+          }
+          if (pmField.startsWith("npm@") || pmField === "npm") {
+            return { name: "npm", source: "package-json", confident: true };
+          }
+        }
+      } catch {
+      }
+    }
+    const parent = path2.dirname(curDir);
+    if (parent === curDir) break;
+    curDir = parent;
+  }
+  curDir = startDir;
+  while (true) {
+    const found = [];
+    if (fsImpl.existsSync(path2.join(curDir, "bun.lock")) || fsImpl.existsSync(path2.join(curDir, "bun.lockb"))) {
+      found.push("bun");
+    }
+    if (fsImpl.existsSync(path2.join(curDir, "pnpm-lock.yaml"))) {
+      found.push("pnpm");
+    }
+    if (fsImpl.existsSync(path2.join(curDir, "yarn.lock"))) {
+      found.push("yarn");
+    }
+    if (fsImpl.existsSync(path2.join(curDir, "package-lock.json")) || fsImpl.existsSync(path2.join(curDir, "npm-shrinkwrap.json"))) {
+      found.push("npm");
+    }
+    if (found.length === 1) {
+      return { name: found[0], source: "lockfile", confident: true };
+    }
+    if (found.length > 1) {
+      const priority = ["bun", "pnpm", "yarn", "npm"];
+      const chosen = priority.find((p3) => found.includes(p3));
+      return { name: chosen, source: "lockfile", confident: false };
+    }
+    if (fsImpl.existsSync(path2.join(curDir, ".git"))) {
+      break;
+    }
+    const parent = path2.dirname(curDir);
+    if (parent === curDir) break;
+    curDir = parent;
+  }
+  if (argv1) {
+    try {
+      const real = fsImpl.existsSync(argv1) ? fsImpl.realpathSync(argv1) : argv1;
+      const normalized = real.replace(/\\/g, "/").toLowerCase();
+      if (normalized.includes("/.bun/") || normalized.includes("/bun/bin/")) {
+        return { name: "bun", source: "global-path", confident: false };
+      }
+      if (normalized.includes("/pnpm/global/") || normalized.includes("/appdata/local/pnpm")) {
+        return { name: "pnpm", source: "global-path", confident: false };
+      }
+      if (normalized.includes("/yarn/global/") || normalized.includes("/.config/yarn/global/") || normalized.includes("/appdata/local/yarn")) {
+        return { name: "yarn", source: "global-path", confident: false };
+      }
+    } catch {
+    }
+  }
+  if (versions && versions.bun) {
+    return { name: "bun", source: "runtime", confident: false };
+  }
+  return { name: "npm", source: "default", confident: false };
+}
+function formatPmSource(source) {
+  switch (source) {
+    case "flag":
+      return "command line flag";
+    case "user-agent":
+      return "user agent";
+    case "package-json":
+      return "package.json packageManager field";
+    case "lockfile":
+      return "lockfile";
+    case "global-path":
+      return "global installation directory";
+    case "runtime":
+      return "runtime environment";
+    case "prompt":
+      return "user selection";
+    case "default":
+      return "default fallback";
+  }
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "npm":
+      return "npm install";
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun install";
+  }
+}
+function getRunCommand(pm, script) {
+  switch (pm) {
+    case "npm":
+      return `npm run ${script}`;
+    case "pnpm":
+      return `pnpm ${script}`;
+    case "yarn":
+      return `yarn ${script}`;
+    case "bun":
+      return `bun run ${script}`;
+  }
+}
+
+// src/utils/exec.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import path3 from "path";
+function isCommandAvailable(command) {
+  return new Promise((resolve) => {
+    const isWindows = process.platform === "win32";
+    const child = spawn(command, ["--version"], {
+      shell: isWindows,
+      stdio: "ignore"
+    });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+}
+function isInsideGitRepo(dir) {
+  let cur = path3.resolve(dir);
+  while (true) {
+    if (fs2.existsSync(path3.join(cur, ".git"))) {
+      return true;
+    }
+    const parent = path3.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return false;
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve) => {
+    const isWindows = process.platform === "win32";
+    const child = spawn(command, args, {
+      cwd,
+      shell: isWindows,
+      stdio: "inherit"
+    });
+    child.on("error", (err) => resolve({ success: false, error: err.message }));
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ success: true });
+      } else {
+        resolve({ success: false, error: `Exited with code ${code}` });
+      }
+    });
+  });
+}
+
+// src/cli/prompts.ts
+async function runPrompts(args) {
+  const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const useDefaults = Boolean(args.yes);
+  function handleCancel(value) {
+    if (p.isCancel(value)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    return value;
+  }
+  let projectName = args.name;
+  let targetDir = args.dir;
+  if (!projectName && !targetDir) {
+    if (!isTTY && !useDefaults) {
+      throw new Error("Missing project name or target directory. Provide [dir] or --name.");
+    }
+    if (useDefaults) {
+      projectName = "my-extension";
+      targetDir = "my-extension";
+    } else {
+      const nameInput = handleCancel(
+        await p.text({
+          message: "Project name:",
+          placeholder: "my-extension",
+          defaultValue: "my-extension",
+          validate(val) {
+            const trimmed = val ? val.trim() : "";
+            if (!trimmed) return "Project name cannot be empty.";
+            const check = validatePackageName(trimmed);
+            return check === true ? void 0 : check;
+          }
+        })
+      );
+      projectName = nameInput.trim();
+      targetDir = projectName;
+    }
+  } else if (!projectName && targetDir) {
+    projectName = getPackageName(targetDir);
+  } else if (projectName && !targetDir) {
+    targetDir = projectName;
+  }
+  const resolvedTargetDir = path4.resolve(targetDir);
+  let ifExists = args.ifExists || "cancel";
+  const dirExists = fs3.existsSync(resolvedTargetDir);
+  const dirHasFiles = dirExists && fs3.readdirSync(resolvedTargetDir).length > 0;
+  if (dirHasFiles && !args.ifExists) {
+    if (!isTTY && !useDefaults) {
+      throw new Error(
+        `Target directory "${targetDir}" is not empty. Specify --if-exists or --overwrite.`
+      );
+    }
+    if (useDefaults) {
+      throw new Error(
+        `Target directory "${targetDir}" is not empty and default action is cancel.`
+      );
+    }
+    ifExists = handleCancel(
+      await p.select({
+        message: `Target directory "${targetDir}" is not empty. How to proceed?`,
+        options: [
+          { value: "cancel", label: "Cancel", hint: "Exit without modifying files" },
+          { value: "overwrite", label: "Overwrite", hint: "Delete existing files and proceed" },
+          { value: "merge", label: "Merge", hint: "Keep existing files and add extension files" }
+        ],
+        initialValue: "cancel"
+      })
+    );
+    if (ifExists === "cancel") {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  }
+  let language = args.lang || (useDefaults ? "ts" : void 0);
+  if (!language) {
+    if (!isTTY) throw new Error("Missing --lang flag in non-interactive environment.");
+    language = handleCancel(
+      await p.select({
+        message: "Select language:",
+        options: [
+          { value: "ts", label: "TypeScript", hint: "Recommended" },
+          { value: "js", label: "JavaScript" }
+        ],
+        initialValue: "ts"
+      })
+    );
+  }
+  let projectType = args.type || (useDefaults ? "full" : void 0);
+  if (!projectType) {
+    if (!isTTY) throw new Error("Missing --type flag in non-interactive environment.");
+    projectType = handleCancel(
+      await p.select({
+        message: "Select project type:",
+        options: [
+          { value: "full", label: "Full extension", hint: "Background, popup, options, content scripts, etc." },
+          { value: "content-only", label: "Content script only", hint: "DOM injector/script with no extension UI" }
+        ],
+        initialValue: "full"
+      })
+    );
+  }
+  let browsers = args.browser?.length ? args.browser : useDefaults ? ["chrome"] : void 0;
+  if (!browsers) {
+    if (!isTTY) throw new Error("Missing --browser flag in non-interactive environment.");
+    browsers = handleCancel(
+      await p.multiselect({
+        message: "Select target browsers:",
+        options: [
+          { value: "chrome", label: "Chromium (Chrome, Edge, Brave, Opera)", hint: "default" },
+          { value: "firefox", label: "Firefox" },
+          { value: "safari", label: "Safari" }
+        ],
+        initialValues: ["chrome"],
+        required: true
+      })
+    );
+  }
+  let firefoxMv = args.firefoxMv;
+  if (browsers.includes("firefox") && firefoxMv === void 0) {
+    if (useDefaults) {
+      firefoxMv = 3;
+    } else if (!isTTY) {
+      throw new Error("Missing --firefox-mv flag in non-interactive environment.");
+    } else {
+      firefoxMv = handleCancel(
+        await p.select({
+          message: "Manifest version for Firefox:",
+          options: [
+            { value: 3, label: "MV3", hint: "Recommended modern standard" },
+            { value: 2, label: "MV2", hint: "Legacy background page" }
+          ],
+          initialValue: 3
+        })
+      );
+    }
+  }
+  let safariMv = args.safariMv;
+  if (browsers.includes("safari") && safariMv === void 0) {
+    if (useDefaults) {
+      safariMv = 3;
+    } else if (!isTTY) {
+      throw new Error("Missing --safari-mv flag in non-interactive environment.");
+    } else {
+      safariMv = handleCancel(
+        await p.select({
+          message: "Manifest version for Safari:",
+          options: [
+            { value: 3, label: "MV3", hint: "Recommended modern standard" },
+            { value: 2, label: "MV2", hint: "Legacy extension converter target" }
+          ],
+          initialValue: 3
+        })
+      );
+    }
+  }
+  const anyMv2 = browsers.includes("firefox") && firefoxMv === 2 || browsers.includes("safari") && safariMv === 2;
+  const onlySafari = browsers.length === 1 && browsers[0] === "safari";
+  let features = [];
+  if (projectType === "full") {
+    if (args.features !== void 0) {
+      features = args.features;
+    } else if (useDefaults) {
+      features = ["background", "content"];
+    } else if (!isTTY) {
+      throw new Error("Missing --features flag in non-interactive environment.");
+    } else {
+      const featureOptions = [
+        { value: "background", label: "Background", hint: "Service worker or background script" },
+        { value: "content", label: "Content script", hint: "Inject scripts and styles into webpages" },
+        { value: "popup", label: "Popup", hint: "Toolbar action popup HTML dialog" },
+        { value: "options", label: "Options page", hint: "Extension settings interface" }
+      ];
+      if (!onlySafari) {
+        featureOptions.push({
+          value: "sidepanel",
+          label: "Side panel",
+          hint: browsers.includes("safari") ? "Not supported on Safari" : void 0
+        });
+      }
+      if (!anyMv2) {
+        featureOptions.push({
+          value: "dnr",
+          label: "declarativeNetRequest rules",
+          hint: "Declarative network request blocking/redirect rules"
+        });
+      }
+      featureOptions.push({ value: "devtools", label: "DevTools page", hint: "Custom developer tools tab" });
+      featureOptions.push({ value: "newtab", label: "New tab override", hint: "Override default new tab page" });
+      features = handleCancel(
+        await p.multiselect({
+          message: "Select extension features:",
+          options: featureOptions,
+          initialValues: ["background", "content"],
+          required: false
+        })
+      );
+    }
+  }
+  const hasContentScript = projectType === "content-only" || features.includes("content");
+  let contentScriptOptions = void 0;
+  if (hasContentScript) {
+    let matches = args.matches || [];
+    if (matches.length === 0) {
+      if (useDefaults) {
+        matches = ["https://*/*"];
+      } else if (!isTTY) {
+        throw new Error("Missing --matches flag in non-interactive environment.");
+      } else {
+        const matchesInput = handleCancel(
+          await p.text({
+            message: "Content script URL match patterns (comma-separated):",
+            placeholder: "https://*/*",
+            defaultValue: "https://*/*",
+            validate(val) {
+              const res = parseAndValidateMatches(val || "");
+              return res.valid ? void 0 : res.error;
+            }
+          })
+        );
+        const parsed = parseAndValidateMatches(matchesInput);
+        if (parsed.valid) {
+          matches = parsed.matches;
+        } else {
+          matches = ["https://*/*"];
+        }
+      }
+    }
+    let runAt = args.runAt || "document_idle";
+    if (!args.runAt) {
+      if (useDefaults) {
+        runAt = "document_idle";
+      } else if (!isTTY) {
+        throw new Error("Missing --run-at flag in non-interactive environment.");
+      } else {
+        runAt = handleCancel(
+          await p.select({
+            message: "Content script run timing:",
+            options: [
+              { value: "document_idle", label: "document_idle", hint: "Default, after page finishes loading" },
+              { value: "document_start", label: "document_start", hint: "Before any DOM is created" },
+              { value: "document_end", label: "document_end", hint: "Immediately after DOM is parsed" }
+            ],
+            initialValue: "document_idle"
+          })
+        );
+      }
+    }
+    let world = args.world || "ISOLATED";
+    if (!anyMv2 && args.world === void 0) {
+      if (useDefaults) {
+        world = "ISOLATED";
+      } else if (!isTTY) {
+        world = "ISOLATED";
+      } else {
+        world = handleCancel(
+          await p.select({
+            message: "Content script execution world:",
+            options: [
+              { value: "ISOLATED", label: "ISOLATED", hint: "Default, isolated JS execution space" },
+              { value: "MAIN", label: "MAIN", hint: "Share DOM and JS context with page scripts" }
+            ],
+            initialValue: "ISOLATED"
+          })
+        );
+      }
+    }
+    let css = args.css ?? true;
+    if (args.css === void 0) {
+      if (useDefaults) {
+        css = true;
+      } else if (!isTTY) {
+        css = true;
+      } else {
+        css = handleCancel(
+          await p.confirm({
+            message: "Create CSS style file for content script?",
+            initialValue: true
+          })
+        );
+      }
+    }
+    contentScriptOptions = {
+      matches,
+      runAt,
+      world,
+      css
+    };
+  }
+  let extras = [];
+  if (projectType === "full") {
+    if (args.extras !== void 0) {
+      extras = args.extras;
+    } else if (useDefaults) {
+      extras = [];
+    } else if (!isTTY) {
+      extras = [];
+    } else {
+      const extraOptions = [];
+      const hasBackground = features.includes("background");
+      if (hasBackground) {
+        extraOptions.push({
+          value: "contextmenu",
+          label: "Context menu sample",
+          hint: "contextMenus permission + listener"
+        });
+        extraOptions.push({
+          value: "commands",
+          label: "Keyboard shortcut sample",
+          hint: "commands manifest entry + listener"
+        });
+        extraOptions.push({
+          value: "omnibox",
+          label: "Omnibox address bar keyword sample",
+          hint: "omnibox keyword + handler"
+        });
+      }
+      extraOptions.push({
+        value: "storage",
+        label: "Storage helper library",
+        hint: "Type-safe local storage wrapper in src/lib/storage"
+      });
+      if (extraOptions.length > 0) {
+        extras = handleCancel(
+          await p.multiselect({
+            message: "Select optional extra samples:",
+            options: extraOptions,
+            initialValues: [],
+            required: false
+          })
+        );
+      }
+    }
+  }
+  const detectedPm = detectPackageManager({
+    flag: args.pm,
+    targetDir: resolvedTargetDir
+  });
+  let chosenPm = detectedPm.name;
+  if (!args.pm && !detectedPm.confident && isTTY && !useDefaults) {
+    chosenPm = handleCancel(
+      await p.select({
+        message: "Select package manager to use:",
+        options: [
+          { value: "npm", label: "npm" },
+          { value: "pnpm", label: "pnpm" },
+          { value: "yarn", label: "yarn" },
+          { value: "bun", label: "bun" }
+        ],
+        initialValue: detectedPm.name
+      })
+    );
+  } else {
+    p.log.info(`Using ${chosenPm} (detected from ${formatPmSource(detectedPm.source)})`);
+  }
+  let install = args.install ?? true;
+  if (args.install === void 0) {
+    if (useDefaults || !isTTY) {
+      install = true;
+    } else {
+      install = handleCancel(
+        await p.confirm({
+          message: "Install dependencies now?",
+          initialValue: true
+        })
+      );
+    }
+  }
+  let git = args.git ?? true;
+  const alreadyInGit = isInsideGitRepo(resolvedTargetDir);
+  if (args.git === void 0) {
+    if (alreadyInGit) {
+      git = false;
+    } else if (useDefaults || !isTTY) {
+      git = true;
+    } else {
+      git = handleCancel(
+        await p.confirm({
+          message: "Initialize a new git repository?",
+          initialValue: true
+        })
+      );
+    }
+  } else if (git && alreadyInGit) {
+    p.log.warn("Target directory is already inside a git repository; skipping git init.");
+    git = false;
+  }
+  return {
+    projectName: projectName || "my-extension",
+    targetDir: resolvedTargetDir,
+    ifExists,
+    language,
+    projectType,
+    browsers,
+    firefoxMv,
+    safariMv,
+    features,
+    contentScript: contentScriptOptions,
+    extras,
+    pm: chosenPm,
+    install,
+    git,
+    isInteractive: isTTY && !useDefaults
+  };
+}
+
+// src/generate/index.ts
+import fs5 from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+
+// src/generate/targets.ts
+var CAPABILITY_MATRIX = {
+  "chrome-mv3": {
+    supportsBackgroundServiceWorker: true,
+    supportsBackgroundScripts: false,
+    popupKey: "action",
+    supportsSidePanel: true,
+    sidePanelType: "side_panel",
+    supportsDnr: true,
+    supportsDevtools: true,
+    supportsNewtab: true,
+    supportsWorldMain: true
+  },
+  "firefox-mv3": {
+    supportsBackgroundServiceWorker: false,
+    supportsBackgroundScripts: true,
+    popupKey: "action",
+    supportsSidePanel: true,
+    sidePanelType: "sidebar_action",
+    supportsDnr: true,
+    supportsDevtools: true,
+    supportsNewtab: true,
+    supportsWorldMain: true
+  },
+  "firefox-mv2": {
+    supportsBackgroundServiceWorker: false,
+    supportsBackgroundScripts: true,
+    popupKey: "browser_action",
+    supportsSidePanel: true,
+    sidePanelType: "sidebar_action",
+    supportsDnr: false,
+    supportsDevtools: true,
+    supportsNewtab: true,
+    supportsWorldMain: false
+  },
+  "safari-mv3": {
+    supportsBackgroundServiceWorker: true,
+    supportsBackgroundScripts: false,
+    popupKey: "action",
+    supportsSidePanel: false,
+    supportsDnr: true,
+    supportsDevtools: false,
+    supportsNewtab: false,
+    supportsWorldMain: true
+  },
+  "safari-mv2": {
+    supportsBackgroundServiceWorker: false,
+    supportsBackgroundScripts: true,
+    popupKey: "browser_action",
+    supportsSidePanel: false,
+    supportsDnr: false,
+    supportsDevtools: false,
+    supportsNewtab: false,
+    supportsWorldMain: false
+  }
+};
+function resolveTargets(browsers, firefoxMv = 3, safariMv = 3) {
+  const targets = [];
+  for (const b of browsers) {
+    if (b === "chrome") {
+      targets.push({
+        id: "chrome-mv3",
+        browser: "chrome",
+        mv: 3,
+        outDir: "dist/chrome-mv3"
+      });
+    } else if (b === "firefox") {
+      const mv = firefoxMv || 3;
+      targets.push({
+        id: `firefox-mv${mv}`,
+        browser: "firefox",
+        mv,
+        outDir: `dist/firefox-mv${mv}`
+      });
+    } else if (b === "safari") {
+      const mv = safariMv || 3;
+      targets.push({
+        id: `safari-mv${mv}`,
+        browser: "safari",
+        mv,
+        outDir: `dist/safari-mv${mv}`
+      });
+    }
+  }
+  return targets;
+}
+
+// src/generate/manifest.ts
+function buildManifest(ctx, target) {
+  const cap = CAPABILITY_MATRIX[target.id] || {
+    supportsBackgroundServiceWorker: true,
+    supportsBackgroundScripts: false,
+    popupKey: "action",
+    supportsSidePanel: false,
+    supportsDnr: target.mv === 3,
+    supportsDevtools: false,
+    supportsNewtab: false,
+    supportsWorldMain: target.mv === 3
+  };
+  const ext = ctx.language === "ts" ? "ts" : "js";
+  const slug = toSlug(ctx.projectName);
+  const manifest = {
+    manifest_version: target.mv,
+    name: ctx.projectName,
+    version: "0.0.1",
+    description: `${ctx.projectName} browser extension`,
+    icons: {
+      "16": "icons/16.png",
+      "48": "icons/48.png",
+      "128": "icons/128.png"
+    }
+  };
+  if (ctx.projectType === "content-only") {
+    const matches = ctx.contentScript?.matches?.length ? ctx.contentScript.matches : ["https://*/*"];
+    const contentEntry = {
+      matches,
+      js: [`src/content/index.${ext}`],
+      run_at: ctx.contentScript?.runAt || "document_idle"
+    };
+    if (ctx.contentScript?.css) {
+      contentEntry.css = ["src/content/style.css"];
+    }
+    if (target.mv === 3 && cap.supportsWorldMain) {
+      contentEntry.world = ctx.contentScript?.world || "ISOLATED";
+    }
+    manifest.content_scripts = [contentEntry];
+    if (target.browser === "firefox") {
+      manifest.browser_specific_settings = {
+        gecko: {
+          id: `${slug}@example.com`,
+          strict_min_version: target.mv === 3 ? "109.0" : "58.0"
+        }
+      };
+    }
+    return manifest;
+  }
+  const permissions = [];
+  if (ctx.features.includes("background")) {
+    if (target.mv === 3) {
+      if (cap.supportsBackgroundScripts) {
+        manifest.background = {
+          scripts: [`src/background/index.${ext}`]
+        };
+      } else {
+        manifest.background = {
+          service_worker: `src/background/index.${ext}`,
+          type: "module"
+        };
+      }
+    } else {
+      manifest.background = {
+        scripts: [`src/background/index.${ext}`],
+        persistent: false
+      };
+    }
+  }
+  if (ctx.features.includes("popup")) {
+    if (cap.popupKey === "action") {
+      manifest.action = {
+        default_popup: "src/popup/index.html"
+      };
+    } else {
+      manifest.browser_action = {
+        default_popup: "src/popup/index.html"
+      };
+    }
+  }
+  if (ctx.features.includes("options")) {
+    if (target.mv === 3) {
+      manifest.options_ui = {
+        page: "src/options/index.html",
+        open_in_tab: true
+      };
+    } else {
+      manifest.options_ui = {
+        page: "src/options/index.html",
+        chrome_style: true
+      };
+    }
+  }
+  if (ctx.features.includes("sidepanel") && cap.supportsSidePanel) {
+    if (cap.sidePanelType === "side_panel") {
+      manifest.side_panel = {
+        default_path: "src/sidepanel/index.html"
+      };
+      permissions.push("sidePanel");
+    } else if (cap.sidePanelType === "sidebar_action") {
+      manifest.sidebar_action = {
+        default_panel: "src/sidepanel/index.html"
+      };
+    }
+  }
+  if (ctx.features.includes("devtools") && cap.supportsDevtools) {
+    manifest.devtools_page = "src/devtools/devtools.html";
+  }
+  if (ctx.features.includes("newtab") && cap.supportsNewtab) {
+    manifest.chrome_url_overrides = {
+      newtab: "src/newtab/index.html"
+    };
+  }
+  if (ctx.features.includes("content")) {
+    const matches = ctx.contentScript?.matches?.length ? ctx.contentScript.matches : ["https://*/*"];
+    const contentEntry = {
+      matches,
+      js: [`src/content/index.${ext}`],
+      run_at: ctx.contentScript?.runAt || "document_idle"
+    };
+    if (ctx.contentScript?.css) {
+      contentEntry.css = ["src/content/style.css"];
+    }
+    if (target.mv === 3 && cap.supportsWorldMain) {
+      contentEntry.world = ctx.contentScript?.world || "ISOLATED";
+    }
+    manifest.content_scripts = [contentEntry];
+  }
+  if (ctx.features.includes("dnr") && cap.supportsDnr && target.mv === 3) {
+    manifest.declarative_net_request = {
+      rule_resources: [
+        {
+          id: "ruleset_1",
+          enabled: true,
+          path: "rules/rules.json"
+        }
+      ]
+    };
+    permissions.push("declarativeNetRequest");
+    manifest.host_permissions = ["<all_urls>"];
+  }
+  if (ctx.extras.includes("storage")) {
+    permissions.push("storage");
+  }
+  if (ctx.features.includes("background")) {
+    if (ctx.extras.includes("contextmenu")) {
+      permissions.push("contextMenus");
+    }
+    if (ctx.extras.includes("commands")) {
+      manifest.commands = {
+        _execute_action: {
+          suggested_key: {
+            default: "Ctrl+Shift+Y",
+            mac: "Command+Shift+Y"
+          },
+          description: "Toggle extension action"
+        }
+      };
+    }
+    if (ctx.extras.includes("omnibox")) {
+      manifest.omnibox = {
+        keyword: slug.slice(0, 10)
+      };
+    }
+  }
+  if (permissions.length > 0) {
+    manifest.permissions = permissions;
+  }
+  if (target.browser === "firefox") {
+    manifest.browser_specific_settings = {
+      gecko: {
+        id: `${slug}@example.com`,
+        strict_min_version: target.mv === 3 ? "109.0" : "58.0"
+      }
+    };
+  }
+  return manifest;
+}
+
+// src/generate/pkgjson.ts
+function buildPackageJson(ctx, targets) {
+  const scripts = {};
+  for (const t of targets) {
+    if (t.mv === 2 || t.browser === "firefox") {
+      scripts[`dev:${t.browser}`] = `vite build --watch --mode ${t.id}`;
+    } else {
+      scripts[`dev:${t.browser}`] = `vite --mode ${t.id}`;
+    }
+    scripts[`build:${t.browser}`] = `vite build --mode ${t.id}`;
+    if (t.browser === "firefox") {
+      scripts["run:firefox"] = `web-ext run --source-dir dist/${t.id}`;
+    }
+  }
+  const first = targets[0];
+  scripts["dev"] = `npm run dev:${first.browser}`;
+  scripts["build"] = `npm run build:${first.browser}`;
+  if (targets.length > 1) {
+    scripts["build:all"] = targets.map((t) => `npm run build:${t.browser}`).join(" && ");
+  }
+  scripts["typecheck"] = ctx.language === "ts" ? "tsc -b" : "tsc -p jsconfig.json --noEmit";
+  const devDependencies = {
+    vite: "^8.3.6",
+    typescript: "^5.8.2"
+  };
+  const hasMv3 = targets.some((t) => t.mv === 3);
+  if (hasMv3) {
+    devDependencies["@crxjs/vite-plugin"] = "^3.0.0";
+  }
+  const hasChrome = targets.some((t) => t.browser === "chrome");
+  const hasFirefox = targets.some((t) => t.browser === "firefox");
+  const hasSafari = targets.some((t) => t.browser === "safari");
+  if (hasChrome || hasSafari && !hasFirefox) {
+    devDependencies["@types/chrome"] = "^0.3.7";
+  }
+  if (hasFirefox) {
+    devDependencies["@types/firefox-webext-browser"] = "^143.0.1";
+    devDependencies["web-ext"] = "^10.8.0";
+  }
+  return {
+    name: ctx.projectName,
+    version: "0.0.1",
+    description: `${ctx.projectName} browser extension`,
+    type: "module",
+    scripts,
+    devDependencies
+  };
+}
+
+// src/generate/tsconfig.ts
+function buildConfigs(ctx, targets) {
+  const files = {};
+  const types = [];
+  const hasChrome = targets.some((t) => t.browser === "chrome");
+  const hasFirefox = targets.some((t) => t.browser === "firefox");
+  const hasSafari = targets.some((t) => t.browser === "safari");
+  if (hasChrome || hasSafari && !hasFirefox) {
+    types.push("chrome");
+  }
+  if (hasFirefox) {
+    types.push("firefox-webext-browser");
+  }
+  const hasBackground = ctx.projectType === "full" && ctx.features.includes("background");
+  if (ctx.language === "ts") {
+    const references = [{ path: "./tsconfig.app.json" }];
+    if (hasBackground) {
+      references.push({ path: "./tsconfig.background.json" });
+    }
+    references.push({ path: "./tsconfig.node.json" });
+    files["tsconfig.json"] = JSON.stringify(
+      {
+        files: [],
+        references
+      },
+      null,
+      2
+    );
+    const appConfig = {
+      compilerOptions: {
+        target: "ES2022",
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        noEmit: true,
+        isolatedModules: true,
+        skipLibCheck: true,
+        types
+      },
+      include: ["src/**/*"]
+    };
+    if (hasBackground) {
+      appConfig.exclude = ["src/background/**/*"];
+    }
+    files["tsconfig.app.json"] = JSON.stringify(appConfig, null, 2);
+    if (hasBackground) {
+      const bgLib = ["ES2022", "WebWorker"];
+      if (hasFirefox) {
+        bgLib.push("DOM");
+      }
+      files["tsconfig.background.json"] = JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            lib: bgLib,
+            module: "ESNext",
+            moduleResolution: "bundler",
+            strict: true,
+            noEmit: true,
+            isolatedModules: true,
+            skipLibCheck: true,
+            types
+          },
+          include: ["src/background/**/*", "src/lib/**/*"]
+        },
+        null,
+        2
+      );
+    }
+    files["tsconfig.node.json"] = JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          lib: ["ES2022"],
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          noEmit: true,
+          isolatedModules: true,
+          skipLibCheck: true
+        },
+        include: [
+          "vite.config.ts",
+          "manifest.config.ts",
+          "targets.config.ts",
+          "build/**/*"
+        ]
+      },
+      null,
+      2
+    );
+  } else {
+    files["jsconfig.json"] = JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          lib: ["ES2022", "DOM", "DOM.Iterable"],
+          module: "ESNext",
+          moduleResolution: "bundler",
+          checkJs: true,
+          noEmit: true,
+          types
+        },
+        include: [
+          "src/**/*",
+          "vite.config.js",
+          "manifest.config.js",
+          "targets.config.js",
+          "build/**/*"
+        ]
+      },
+      null,
+      2
+    );
+  }
+  const hasMv3 = targets.some((t) => t.mv === 3);
+  const envDtsLines = ['/// <reference types="vite/client" />'];
+  if (hasMv3) {
+    envDtsLines.push('/// <reference types="@crxjs/vite-plugin/client" />');
+  }
+  files["src/env.d.ts"] = envDtsLines.join("\n") + "\n";
+  return files;
+}
+
+// src/generate/copy.ts
+import fs4 from "fs";
+import path5 from "path";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".ico", ".webp", ".woff", ".woff2", ".ttf"]);
+function copyDirectory(sourceDir, targetDir, replacements = {}) {
+  if (!fs4.existsSync(sourceDir)) {
+    return;
+  }
+  const entries = fs4.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path5.join(sourceDir, entry.name);
+    const targetName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+    const destPath = path5.join(targetDir, targetName);
+    if (entry.isDirectory()) {
+      fs4.mkdirSync(destPath, { recursive: true });
+      copyDirectory(srcPath, destPath, replacements);
+    } else if (entry.isFile()) {
+      fs4.mkdirSync(path5.dirname(destPath), { recursive: true });
+      const ext = path5.extname(entry.name).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) {
+        fs4.copyFileSync(srcPath, destPath);
+      } else {
+        let content = fs4.readFileSync(srcPath, "utf-8");
+        for (const [key, val] of Object.entries(replacements)) {
+          const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+          content = content.replace(placeholder, val);
+        }
+        fs4.writeFileSync(destPath, content, "utf-8");
+      }
+    }
+  }
+}
+
+// src/generate/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path6.dirname(__filename);
+function getTemplatesDir() {
+  const candidate1 = path6.resolve(__dirname, "../../templates");
+  if (fs5.existsSync(candidate1)) {
+    return candidate1;
+  }
+  const candidate2 = path6.resolve(__dirname, "../templates");
+  if (fs5.existsSync(candidate2)) {
+    return candidate2;
+  }
+  return path6.resolve(process.cwd(), "templates");
+}
+function buildProjectReadme(ctx, targets) {
+  const pm = ctx.pm;
+  const devCmd = getRunCommand(pm, "dev");
+  const buildCmd = getRunCommand(pm, "build");
+  const firstTarget = targets[0];
+  let loadInstructions = "";
+  for (const t of targets) {
+    if (t.browser === "chrome") {
+      loadInstructions += `
+### Chromium (Chrome, Edge, Brave, Opera)
+1. Open \`chrome://extensions\` (or equivalent in your browser)
+2. Enable **Developer mode** toggle in the top-right corner
+3. Click **Load unpacked** and select the \`${t.outDir}\` directory
+`;
+    } else if (t.browser === "firefox") {
+      loadInstructions += `
+### Firefox
+1. Open \`about:debugging#/runtime/this-firefox\`
+2. Click **Load Temporary Add-on...**
+3. Select the \`manifest.json\` file inside \`${t.outDir}\`
+*(Alternatively, run \`${getRunCommand(pm, "run:firefox")}\`)*
+`;
+    } else if (t.browser === "safari") {
+      loadInstructions += `
+### Safari
+Safari requires converting the built extension with Xcode:
+\`\`\`bash
+xcrun safari-web-extension-converter ${t.outDir}
+\`\`\`
+Then open and run the generated Xcode project.
+`;
+    }
+  }
+  const scriptList = Object.entries(buildPackageJson(ctx, targets).scripts).map(([name, cmd]) => `- \`${getRunCommand(pm, name)}\`: \`${cmd}\``).join("\n");
+  return `# ${ctx.projectName}
+
+${ctx.projectName} browser extension built with Vite and CRXJS.
+
+## Getting Started
+
+### Development
+\`\`\`bash
+${devCmd}
+\`\`\`
+
+### Production Build
+\`\`\`bash
+${buildCmd}
+\`\`\`
+
+## Available Scripts
+${scriptList}
+
+## Loading the Extension in Your Browser
+${loadInstructions}
+
+## Before Publishing
+- Update the extension name, description, and icons in \`public/icons/\`.
+${targets.some((t) => t.browser === "firefox") ? "- Customize the Firefox Gecko ID in `manifest.config` (default is placeholder `@example.com`).\n" : ""}${ctx.features.includes("dnr") ? "- Review the default rules in `public/rules/rules.json` and narrow `host_permissions` in the manifest.\n" : ""}
+`;
+}
+function generateProject(ctx) {
+  const targetDir = path6.resolve(ctx.targetDir);
+  const templatesDir = getTemplatesDir();
+  const slug = toSlug(ctx.projectName);
+  const targets = resolveTargets(ctx.browsers, ctx.firefoxMv, ctx.safariMv);
+  const hasMv2 = targets.some((t) => t.mv === 2);
+  const ext = ctx.language === "ts" ? "ts" : "js";
+  const replacements = {
+    name: ctx.projectName,
+    description: `${ctx.projectName} browser extension`,
+    slug,
+    pm: ctx.pm
+  };
+  fs5.mkdirSync(targetDir, { recursive: true });
+  const baseDir = path6.join(templatesDir, "base");
+  copyDirectory(baseDir, targetDir, replacements);
+  const langDir = path6.join(templatesDir, ctx.language);
+  copyDirectory(langDir, targetDir, replacements);
+  if (ctx.projectType === "content-only") {
+    const contentDir = path6.join(templatesDir, "features", "content", "content-only", ctx.language);
+    copyDirectory(contentDir, targetDir, replacements);
+    if (ctx.contentScript?.css) {
+      const styleSrc = path6.join(templatesDir, "features", "content", "style.css");
+      const styleDest = path6.join(targetDir, "src", "content", "style.css");
+      fs5.mkdirSync(path6.dirname(styleDest), { recursive: true });
+      fs5.copyFileSync(styleSrc, styleDest);
+    }
+  } else {
+    if (ctx.features.includes("background")) {
+      const bgDir = path6.join(templatesDir, "features", "background", ctx.language);
+      copyDirectory(bgDir, targetDir, replacements);
+      const bgFile = path6.join(targetDir, "src", "background", `index.${ext}`);
+      let bgContent = fs5.readFileSync(bgFile, "utf-8");
+      if (ctx.extras.includes("contextmenu")) {
+        bgContent += `
+api.contextMenus?.create?.({
+  id: '${slug}-menu',
+  title: '${ctx.projectName} Action',
+  contexts: ['all'],
+});
+
+api.contextMenus?.onClicked?.addListener((info, tab) => {
+  console.log('Context menu clicked:', info.menuItemId, 'tab:', tab?.id);
+});
+`;
+      }
+      if (ctx.extras.includes("commands")) {
+        bgContent += `
+api.commands?.onCommand?.addListener((command) => {
+  console.log('Command received:', command);
+});
+`;
+      }
+      if (ctx.extras.includes("omnibox")) {
+        bgContent += `
+api.omnibox?.onInputEntered?.addListener((text, disposition) => {
+  console.log('Omnibox search:', text, 'disposition:', disposition);
+});
+`;
+      }
+      fs5.writeFileSync(bgFile, bgContent, "utf-8");
+    }
+    if (ctx.features.includes("content")) {
+      const contentDir = path6.join(templatesDir, "features", "content", "full", ctx.language);
+      copyDirectory(contentDir, targetDir, replacements);
+      if (ctx.contentScript?.css) {
+        const styleSrc = path6.join(templatesDir, "features", "content", "style.css");
+        const styleDest = path6.join(targetDir, "src", "content", "style.css");
+        fs5.mkdirSync(path6.dirname(styleDest), { recursive: true });
+        fs5.copyFileSync(styleSrc, styleDest);
+      }
+    }
+    if (ctx.features.includes("popup")) {
+      const popupDir = path6.join(templatesDir, "features", "popup", ctx.language);
+      copyDirectory(popupDir, targetDir, replacements);
+    }
+    if (ctx.features.includes("options")) {
+      const optionsDir = path6.join(templatesDir, "features", "options", ctx.language);
+      copyDirectory(optionsDir, targetDir, replacements);
+    }
+    if (ctx.features.includes("sidepanel")) {
+      const sidepanelDir = path6.join(templatesDir, "features", "sidepanel", ctx.language);
+      copyDirectory(sidepanelDir, targetDir, replacements);
+    }
+    if (ctx.features.includes("devtools")) {
+      const devtoolsDir = path6.join(templatesDir, "features", "devtools", ctx.language);
+      copyDirectory(devtoolsDir, targetDir, replacements);
+    }
+    if (ctx.features.includes("newtab")) {
+      const newtabDir = path6.join(templatesDir, "features", "newtab", ctx.language);
+      copyDirectory(newtabDir, targetDir, replacements);
+    }
+    if (ctx.features.includes("dnr")) {
+      const dnrSrc = path6.join(templatesDir, "features", "dnr", "rules.json");
+      const dnrDest = path6.join(targetDir, "public", "rules", "rules.json");
+      fs5.mkdirSync(path6.dirname(dnrDest), { recursive: true });
+      fs5.copyFileSync(dnrSrc, dnrDest);
+    }
+    if (ctx.extras.includes("storage")) {
+      const storageDir = path6.join(templatesDir, "features", "extras", "storage", ctx.language);
+      copyDirectory(storageDir, targetDir, replacements);
+    }
+  }
+  const targetsConfigContent = `export interface TargetConfig {
+  id: string;
+  browser: 'chrome' | 'firefox' | 'safari';
+  mv: 2 | 3;
+  outDir: string;
+}
+
+export const targets: TargetConfig[] = ${JSON.stringify(targets, null, 2)};
+
+export function getTarget(mode: string): TargetConfig {
+  const found = targets.find((t) => t.id === mode);
+  return found || targets[0];
+}
+`;
+  fs5.writeFileSync(
+    path6.join(targetDir, `targets.config.${ext}`),
+    ctx.language === "ts" ? targetsConfigContent : targetsConfigContent.replace(/export interface TargetConfig \{[\s\S]*?\}\n\n/, "").replace(/: TargetConfig\[\]/g, "").replace(/: string/g, "").replace(/: TargetConfig/g, ""),
+    "utf-8"
+  );
+  const manifestMap = {};
+  for (const t of targets) {
+    manifestMap[t.id] = buildManifest(ctx, t);
+  }
+  const manifestConfigContent = ctx.language === "ts" ? `import type { TargetConfig } from './targets.config';
+
+const manifests: Record<string, any> = ${JSON.stringify(manifestMap, null, 2)};
+
+export function buildManifest(target: TargetConfig): any {
+  return manifests[target.id] || manifests['${targets[0].id}'];
+}
+` : `const manifests = ${JSON.stringify(manifestMap, null, 2)};
+
+export function buildManifest(target) {
+  return manifests[target.id] || manifests['${targets[0].id}'];
+}
+`;
+  fs5.writeFileSync(path6.join(targetDir, `manifest.config.${ext}`), manifestConfigContent, "utf-8");
+  if (hasMv2) {
+    const mv2Dir = path6.join(targetDir, "build");
+    fs5.mkdirSync(mv2Dir, { recursive: true });
+    const mv2Content = ctx.language === "ts" ? `import type { Plugin } from 'vite';
+import { build as viteBuild } from 'vite';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function buildMv2Plugin(options: { target: any; manifest: any }): Plugin {
+  const { manifest } = options;
+  let config: any;
+
+  return {
+    name: 'web-extension:mv2-builder',
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async writeBundle() {
+      const outDir = config.build.outDir;
+      const root = config.root || process.cwd();
+      const mv2Manifest = JSON.parse(JSON.stringify(manifest));
+
+      if (manifest.background?.scripts?.length) {
+        const outScripts: string[] = [];
+        for (let i = 0; i < manifest.background.scripts.length; i++) {
+          const entryPath = path.resolve(root, manifest.background.scripts[i]);
+          const outName = 'background.js';
+          await viteBuild({
+            configFile: false,
+            root,
+            build: {
+              lib: {
+                entry: entryPath,
+                formats: ['iife'],
+                name: 'ExtensionBackground',
+                fileName: () => outName,
+              },
+              outDir,
+              emptyOutDir: false,
+              sourcemap: config.build.sourcemap,
+            },
+          });
+          outScripts.push(outName);
+        }
+        mv2Manifest.background.scripts = outScripts;
+      }
+
+      if (manifest.content_scripts?.length) {
+        for (let sIdx = 0; sIdx < manifest.content_scripts.length; sIdx++) {
+          const cs = manifest.content_scripts[sIdx];
+          if (cs.js?.length) {
+            const outJs: string[] = [];
+            for (let jIdx = 0; jIdx < cs.js.length; jIdx++) {
+              const entryPath = path.resolve(root, cs.js[jIdx]);
+              const outName = \`content-\${sIdx}-\${jIdx}.js\`;
+              await viteBuild({
+                configFile: false,
+                root,
+                build: {
+                  lib: {
+                    entry: entryPath,
+                    formats: ['iife'],
+                    name: \`ExtensionContent_\${sIdx}_\${jIdx}\`,
+                    fileName: () => outName,
+                  },
+                  outDir,
+                  emptyOutDir: false,
+                  sourcemap: config.build.sourcemap,
+                },
+              });
+              outJs.push(outName);
+            }
+            mv2Manifest.content_scripts[sIdx].js = outJs;
+          }
+
+          if (cs.css?.length) {
+            const outCss: string[] = [];
+            for (let cIdx = 0; cIdx < cs.css.length; cIdx++) {
+              const srcCss = path.resolve(root, cs.css[cIdx]);
+              const outCssName = \`content-\${sIdx}-\${cIdx}.css\`;
+              if (fs.existsSync(srcCss)) {
+                fs.copyFileSync(srcCss, path.join(outDir, outCssName));
+                outCss.push(outCssName);
+              }
+            }
+            mv2Manifest.content_scripts[sIdx].css = outCss;
+          }
+        }
+      }
+
+      const iconsDir = path.resolve(root, 'public', 'icons');
+      if (fs.existsSync(iconsDir)) {
+        const outIcons = path.join(outDir, 'icons');
+        fs.mkdirSync(outIcons, { recursive: true });
+        for (const icon of fs.readdirSync(iconsDir)) {
+          fs.copyFileSync(path.join(iconsDir, icon), path.join(outIcons, icon));
+        }
+      }
+
+      fs.writeFileSync(
+        path.join(outDir, 'manifest.json'),
+        JSON.stringify(mv2Manifest, null, 2),
+      );
+    },
+  };
+}
+` : `import { build as viteBuild } from 'vite';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function buildMv2Plugin(options) {
+  const { manifest } = options;
+  let config;
+
+  return {
+    name: 'web-extension:mv2-builder',
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async writeBundle() {
+      const outDir = config.build.outDir;
+      const root = config.root || process.cwd();
+      const mv2Manifest = JSON.parse(JSON.stringify(manifest));
+
+      if (manifest.background?.scripts?.length) {
+        const outScripts = [];
+        for (let i = 0; i < manifest.background.scripts.length; i++) {
+          const entryPath = path.resolve(root, manifest.background.scripts[i]);
+          const outName = 'background.js';
+          await viteBuild({
+            configFile: false,
+            root,
+            build: {
+              lib: {
+                entry: entryPath,
+                formats: ['iife'],
+                name: 'ExtensionBackground',
+                fileName: () => outName,
+              },
+              outDir,
+              emptyOutDir: false,
+              sourcemap: config.build.sourcemap,
+            },
+          });
+          outScripts.push(outName);
+        }
+        mv2Manifest.background.scripts = outScripts;
+      }
+
+      if (manifest.content_scripts?.length) {
+        for (let sIdx = 0; sIdx < manifest.content_scripts.length; sIdx++) {
+          const cs = manifest.content_scripts[sIdx];
+          if (cs.js?.length) {
+            const outJs = [];
+            for (let jIdx = 0; jIdx < cs.js.length; jIdx++) {
+              const entryPath = path.resolve(root, cs.js[jIdx]);
+              const outName = \`content-\${sIdx}-\${jIdx}.js\`;
+              await viteBuild({
+                configFile: false,
+                root,
+                build: {
+                  lib: {
+                    entry: entryPath,
+                    formats: ['iife'],
+                    name: \`ExtensionContent_\${sIdx}_\${jIdx}\`,
+                    fileName: () => outName,
+                  },
+                  outDir,
+                  emptyOutDir: false,
+                  sourcemap: config.build.sourcemap,
+                },
+              });
+              outJs.push(outName);
+            }
+            mv2Manifest.content_scripts[sIdx].js = outJs;
+          }
+
+          if (cs.css?.length) {
+            const outCss = [];
+            for (let cIdx = 0; cIdx < cs.css.length; cIdx++) {
+              const srcCss = path.resolve(root, cs.css[cIdx]);
+              const outCssName = \`content-\${sIdx}-\${cIdx}.css\`;
+              if (fs.existsSync(srcCss)) {
+                fs.copyFileSync(srcCss, path.join(outDir, outCssName));
+                outCss.push(outCssName);
+              }
+            }
+            mv2Manifest.content_scripts[sIdx].css = outCss;
+          }
+        }
+      }
+
+      const iconsDir = path.resolve(root, 'public', 'icons');
+      if (fs.existsSync(iconsDir)) {
+        const outIcons = path.join(outDir, 'icons');
+        fs.mkdirSync(outIcons, { recursive: true });
+        for (const icon of fs.readdirSync(iconsDir)) {
+          fs.copyFileSync(path.join(iconsDir, icon), path.join(outIcons, icon));
+        }
+      }
+
+      fs.writeFileSync(
+        path.join(outDir, 'manifest.json'),
+        JSON.stringify(mv2Manifest, null, 2),
+      );
+    },
+  };
+}
+`;
+    fs5.writeFileSync(path6.join(mv2Dir, `mv2.${ext}`), mv2Content, "utf-8");
+  }
+  const hasMv3 = targets.some((t) => t.mv === 3);
+  let pluginsExpression = "";
+  if (hasMv3 && hasMv2) {
+    pluginsExpression = `isMv3
+      ? [
+          crx({
+            manifest,
+            browser: target.browser === 'firefox' ? 'firefox' : 'chrome',
+          }),
+        ]
+      : [buildMv2Plugin({ target, manifest })]`;
+  } else if (hasMv3) {
+    pluginsExpression = `[
+          crx({
+            manifest,
+            browser: target.browser === 'firefox' ? 'firefox' : 'chrome',
+          }),
+        ]`;
+  } else {
+    pluginsExpression = `[buildMv2Plugin({ target, manifest })]`;
+  }
+  const viteConfigContent = `import { defineConfig } from 'vite';
+${hasMv3 ? "import { crx } from '@crxjs/vite-plugin';" : ""}
+import { getTarget } from './targets.config';
+import { buildManifest } from './manifest.config';
+${hasMv2 ? "import { buildMv2Plugin } from './build/mv2';" : ""}
+
+function getHtmlInputs(manifest${ctx.language === "ts" ? ": any" : ""}) {
+  const inputs${ctx.language === "ts" ? ": Record<string, string>" : ""} = {};
+  if (manifest.action?.default_popup || manifest.browser_action?.default_popup) {
+    inputs.popup = manifest.action?.default_popup || manifest.browser_action?.default_popup;
+  }
+  if (manifest.options_ui?.page) {
+    inputs.options = manifest.options_ui.page;
+  }
+  if (manifest.side_panel?.default_path || manifest.sidebar_action?.default_panel) {
+    inputs.sidepanel = manifest.side_panel?.default_path || manifest.sidebar_action?.default_panel;
+  }
+  if (manifest.devtools_page) {
+    inputs.devtools = manifest.devtools_page;
+  }
+  if (manifest.chrome_url_overrides?.newtab) {
+    inputs.newtab = manifest.chrome_url_overrides.newtab;
+  }
+  return inputs;
+}
+
+export default defineConfig(({ mode }) => {
+  const target = getTarget(mode);
+  const manifest = buildManifest(target);
+  const isMv3 = target.mv === 3;
+
+  const htmlInputs = !isMv3 ? getHtmlInputs(manifest) : {};
+  const hasInputs = Object.keys(htmlInputs).length > 0;
+
+  return {
+    build: {
+      outDir: \`dist/\${target.id}\`,
+      emptyOutDir: true,
+      ...(!isMv3
+        ? {
+            rollupOptions: hasInputs
+              ? { input: htmlInputs }
+              : undefined,
+            ...(hasInputs
+              ? {}
+              : {
+                  lib: {
+                    entry: manifest.content_scripts?.[0]?.js?.[0] || 'src/content/index.${ext}',
+                    formats: ['iife'],
+                    name: 'ExtensionContent',
+                    fileName: () => 'content-0-0.js',
+                  },
+                }),
+          }
+        : {}),
+    },
+    plugins: ${pluginsExpression},
+  };
+});
+`;
+  fs5.writeFileSync(path6.join(targetDir, `vite.config.${ext}`), viteConfigContent, "utf-8");
+  const pkgJson = buildPackageJson(ctx, targets);
+  fs5.writeFileSync(path6.join(targetDir, "package.json"), JSON.stringify(pkgJson, null, 2), "utf-8");
+  const configs = buildConfigs(ctx, targets);
+  for (const [relPath, content] of Object.entries(configs)) {
+    const fullPath = path6.join(targetDir, relPath);
+    fs5.mkdirSync(path6.dirname(fullPath), { recursive: true });
+    fs5.writeFileSync(fullPath, content, "utf-8");
+  }
+  const readmeContent = buildProjectReadme(ctx, targets);
+  fs5.writeFileSync(path6.join(targetDir, "README.md"), readmeContent, "utf-8");
+  return { targetDir, targets };
+}
+
+// src/index.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path7.dirname(__filename2);
+function getCliVersion() {
+  try {
+    const pkgPath = path7.resolve(__dirname2, "../package.json");
+    if (fs6.existsSync(pkgPath)) {
+      const data = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+      return data.version || "2.0.0";
+    }
+  } catch {
+  }
+  return "2.0.0";
+}
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  let parsedArgs;
+  try {
+    parsedArgs = parseCliArgs(rawArgs);
+  } catch (err) {
+    console.error(pico.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+  if (parsedArgs.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (parsedArgs.version) {
+    console.log(`web-extension v${getCliVersion()}`);
+    process.exit(0);
+  }
+  try {
+    validateFlagCombinations(parsedArgs);
+  } catch (err) {
+    console.error(pico.red(`Configuration Error: ${err.message}`));
+    process.exit(1);
+  }
+  p2.intro(pico.bold(pico.cyan("web-extension scaffold")));
+  for (const warning of parsedArgs.warnings) {
+    p2.log.warn(warning);
+  }
+  let ctx;
+  try {
+    ctx = await runPrompts(parsedArgs);
+  } catch (err) {
+    console.error(pico.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+  if (ctx.ifExists === "overwrite" && fs6.existsSync(ctx.targetDir)) {
+    const entries = fs6.readdirSync(ctx.targetDir);
+    for (const entry of entries) {
+      fs6.rmSync(path7.join(ctx.targetDir, entry), { recursive: true, force: true });
+    }
+  }
+  const s = p2.spinner();
+  s.start("Generating project files...");
+  try {
+    generateProject(ctx);
+    s.stop("Project files created successfully.");
+  } catch (err) {
+    s.stop("Failed to generate project files.");
+    console.error(pico.red(err.message));
+    process.exit(1);
+  }
+  if (ctx.git) {
+    s.start("Initializing git repository...");
+    const gitRes = await runCommand("git", ["init"], ctx.targetDir);
+    if (gitRes.success) {
+      s.stop("Git repository initialized.");
+    } else {
+      s.stop("Skipped git initialization.");
+      p2.log.warn(`Git init failed: ${gitRes.error}`);
+    }
+  }
+  if (ctx.install) {
+    const pmAvailable = await isCommandAvailable(ctx.pm);
+    if (!pmAvailable) {
+      p2.log.warn(
+        `Package manager "${ctx.pm}" is not found in PATH. Skipping dependency installation.`
+      );
+      p2.log.info(`Please run "${getInstallCommand(ctx.pm)}" manually.`);
+    } else {
+      s.start(`Installing dependencies with ${ctx.pm}...`);
+      const installCmd = ctx.pm === "yarn" ? [] : ["install"];
+      const installRes = await runCommand(ctx.pm, installCmd, ctx.targetDir);
+      if (installRes.success) {
+        s.stop("Dependencies installed successfully.");
+      } else {
+        s.stop("Failed to install dependencies.");
+        p2.log.warn(`Installation failed: ${installRes.error}`);
+        p2.log.info(`You can try running "${getInstallCommand(ctx.pm)}" manually.`);
+      }
+    }
+  }
+  const relPath = path7.relative(process.cwd(), ctx.targetDir);
+  const cdInstruction = relPath && relPath !== "." ? `cd ${relPath}
+  ` : "";
+  const firstBrowser = ctx.browsers[0];
+  const devCommand = getRunCommand(ctx.pm, `dev:${firstBrowser}`);
+  p2.outro(
+    pico.green(
+      `Done! To get started:
+
+  ${pico.bold(
+        `${cdInstruction}${devCommand}`
+      )}
+`
+    )
+  );
+}
+main().catch((err) => {
+  console.error(pico.red(`Fatal Error: ${err.message}`));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map