create-mcp-use-app 0.14.17 → 2.0.0-beta.1

package/dist/index.js

@@ -1,35 +1,1269 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      to(x, y) {
+        if (!y) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y + 1};${x + 1}H`;
+      },
+      move(x, y) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y < 0) ret += `${CSI2}${-y}A`;
+        else if (y > 0) ret += `${CSI2}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase3 = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
 
-// src/index.tsx
-import chalk from "chalk";
-import { Command } from "commander";
-import { Box, render, Text } from "ink";
-import SelectInput from "ink-select-input";
-import TextInput from "ink-text-input";
+// src/index.ts
 import { spawn, spawnSync } from "child_process";
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync,
   mkdtempSync,
-  readdirSync as readdirSync2,
+  readdirSync as readdirSync3,
   readFileSync as readFileSync2,
   rmSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { tmpdir } from "os";
-import { dirname, join as join2 } from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
+import { dirname as dirname2, join as join3 } from "path";
+import { parseArgs } from "util";
 import { fileURLToPath } from "url";
-import ora from "ora";
-import React, { useState } from "react";
-import { extract } from "tar";
+
+// src/ansi.ts
+var wrap = (code) => (text2) => `\x1B[${code}m${text2}\x1B[0m`;
+var bold = wrap("1");
+var red = wrap("31");
+var green = wrap("32");
+var yellow = wrap("33");
+var cyan = wrap("36");
+var gray = wrap("90");
+var white = wrap("37");
+var whiteBold = (text2) => `\x1B[1;37m${text2}\x1B[0m`;
+
+// ../../node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+import { styleText } from "util";
+import { stdout, stdin } from "process";
+import * as l from "readline";
+import l__default from "readline";
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i2 = 0, l2 = PARSE_BLOCKS.length; i2 < l2; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/.pnpm/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// ../../node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "tty";
+function findCursor(s, o, l2) {
+  if (!l2.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o, n3 = Math.max(l2.length - 1, 0), e = t2 < 0 ? n3 : t2 > n3 ? 0 : t2;
+  return l2[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l2) : e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n3, e) => `There are only ${n3} days in ${e}`,
+      afterMin: (n3) => `Date must be on or after ${n3.toISOString().slice(0, 10)}`,
+      beforeMax: (n3) => `Date must be on or before ${n3.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n3, e) {
+  if (typeof n3 == "string")
+    return settings.aliases.get(n3) === e;
+  for (const s of n3)
+    if (s !== void 0 && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e.length, t2.length), f = [];
+  for (let n3 = 0; n3 < r2; n3++)
+    e[n3] !== t2[n3] && f.push(n3);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r2) {
+  const o = e;
+  o.isTTY && o.setRawMode(r2);
+}
+function block({
+  input: e = stdin,
+  output: r2 = stdout,
+  overwrite: o = true,
+  hideCursor: t2 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r2,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n3 = (f, { name: a2, sequence: p }) => {
+    const c2 = String(f);
+    if (isActionKey([c2, a2, p], "cancel")) {
+      t2 && r2.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o) return;
+    const i2 = a2 === "return" ? 0 : -1, m = a2 === "return" ? -1 : 0;
+    l.moveCursor(r2, i2, m, () => {
+      l.clearLine(r2, 1, () => {
+        e.once("keypress", n3);
+      });
+    });
+  };
+  return t2 && r2.write(import_sisteransi.cursor.hide), e.once("keypress", n3), () => {
+    e.off("keypress", n3), t2 && r2.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r2, o, t2 = o, s = o, n3) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r2, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c2, i2, m) => {
+    const d = n3 ? n3(c2, i2) : c2;
+    return i2 === 0 ? `${t2}${d}` : i2 === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, n3) {
+  if ("~standard" in e) {
+    const a2 = e["~standard"].validate(n3);
+    if (a2 instanceof Promise)
+      throw new TypeError(
+        "Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic."
+      );
+    return a2.issues?.at(0)?.message;
+  }
+  return e(n3);
+}
+var V = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i2 = stdin, output: n3 = stdout, render: s, signal: r2, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r2, this.input = i2, this.output = n3;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e) {
+    const i2 = this._subscribers.get(t2) ?? [], n3 = [];
+    for (const s of i2)
+      s.cb(...e), s.once && n3.push(() => i2.splice(i2.indexOf(s), 1));
+    for (const s of n3)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener(
+          "abort",
+          () => {
+            this.state = "cancel", this.close();
+          },
+          { once: true }
+        );
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "	";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i2 = runValidation(this.opts.validate, this.value);
+        i2 && (this.error = i2 instanceof Error ? i2.message : i2, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i2 = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n3 = Math.max(0, e.numLinesAfter - i2), s = Math.max(0, e.numLinesBefore - i2);
+          let r2 = e.lines.find((o) => o >= n3);
+          if (r2 === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r2 - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[r2]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - r2 - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n3 < s)
+              r2 = n3;
+            else {
+              const h2 = r2 - s;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r2);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+};
+var r = class extends V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i2) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i2, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var n$1 = class n extends V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === void 0 ? void 0 : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t2 = o === -1 ? 0 : o;
+    this.cursor = this.options[t2]?.disabled ? findCursor(t2, 1, this.options) : t2, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+var n2 = class extends V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}\u2588`;
+    const r2 = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e = t2.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "util";
+import process$1 from "process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+import { existsSync, lstatSync, readdirSync } from "fs";
+import { dirname, join } from "path";
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (o, e) => unicode ? o : e;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_BAR_START_RIGHT = unicodeOr("\u2510", "T");
+var S_BAR_END_RIGHT = unicodeOr("\u2518", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("\u256D", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var symbol = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+  }
+};
+var symbolBar = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_BAR);
+    case "cancel":
+      return styleText2("red", S_BAR);
+    case "error":
+      return styleText2("yellow", S_BAR);
+    case "submit":
+      return styleText2("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o, e) {
+  const r2 = [`${e ? `${styleText2("cyan", S_BAR)}  ` : ""}${o.join(" \u2022 ")}`];
+  return e && r2.push(styleText2("cyan", S_BAR_END)), r2;
+}
+var I = (l2, e, w, p, b, C = false) => {
+  let r2 = e, O = 0;
+  if (C)
+    for (let i2 = p - 1; i2 >= w; i2--) {
+      const m = l2[i2];
+      if (m && (r2 -= m.length), O++, r2 <= b) break;
+    }
+  else
+    for (let i2 = w; i2 < p; i2++) {
+      const m = l2[i2];
+      if (m && (r2 -= m.length), O++, r2 <= b) break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l2,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(p) - C, m = getRows(p), M = styleText2("dim", "..."), v = Math.max(m - r2, 0), a2 = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l2 >= a2 - 3 && (f = Math.max(
+    Math.min(l2 - a2 + 3, e.length - a2),
+    0
+  ));
+  let d = a2 < e.length && f > 0, c2 = a2 < e.length && f + a2 < e.length;
+  const W2 = Math.min(
+    f + a2,
+    e.length
+  ), s = [];
+  let g = 0;
+  d && g++, c2 && g++;
+  const T = f + (d ? 1 : 0), y = W2 - (c2 ? 1 : 0);
+  for (let t2 = T; t2 < y; t2++) {
+    const n3 = e[t2], o = n3 ? w(n3, t2 === l2) : "", h2 = wrapAnsi(o, i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g += h2.length;
+  }
+  if (g > v) {
+    let t2 = 0, n3 = 0, o = g;
+    const h2 = l2 - T;
+    let u3 = v;
+    const L = () => I(s, o, 0, h2, u3), E = () => I(
+      s,
+      o,
+      h2 + 1,
+      s.length,
+      u3,
+      true
+    );
+    d ? ({ lineCount: o, removals: t2 } = L(), o > u3 && (c2 || (u3 -= 1), { lineCount: o, removals: n3 } = E())) : (c2 || (u3 -= 1), { lineCount: o, removals: n3 } = E(), o > u3 && (u3 -= 1, { lineCount: o, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n3 > 0 && (c2 = true, s.splice(s.length - n3, n3));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t2 of s)
+    for (const n3 of t2)
+      x.push(n3);
+  return c2 && x.push(M), x;
+};
+var confirm = (i2) => {
+  const a2 = i2.active ?? "Yes", s = i2.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValue: i2.initialValue ?? true,
+    render() {
+      const e = i2.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l2 = e ? `${styleText2("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(
+        i2.output,
+        i2.message,
+        l2,
+        u3
+      ), o = `${e ? `${styleText2("gray", S_BAR)}
+` : ""}${f}
+`, c2 = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o}${r2}${styleText2(["strikethrough", "dim"], c2)}${e ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText2("cyan", S_BAR)}  ` : "", g = e ? styleText2("cyan", S_BAR_END) : "";
+          return `${o}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a2)}`}${i2.vertical ? e ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var cancel = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${styleText2("red", o)}
+
+`);
+};
+var W = (l2) => styleText2("magenta", l2);
+var spinner = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n3 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m,
+  ...I2
+} = {}) => {
+  const u3 = isCI();
+  let M, T, d = false, S = false, s = "", p, w = performance.now();
+  const x = getColumns(n3), k = I2?.styleFrame ?? W, g = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f = () => g(2), i2 = () => g(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i2), process.on("SIGTERM", i2), process.on("exit", g), m && m.addEventListener("abort", i2);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f), process.removeListener("unhandledRejection", f), process.removeListener("SIGINT", i2), process.removeListener("SIGTERM", i2), process.removeListener("exit", g), m && m.removeEventListener("abort", i2);
+  }, y = () => {
+    if (p === void 0) return;
+    u3 && n3.write(`
+`);
+    const r2 = wrapAnsi(p, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r2.length > 1 && n3.write(import_sisteransi2.cursor.up(r2.length - 1)), n3.write(import_sisteransi2.cursor.to(0)), n3.write(import_sisteransi2.erase.down());
+  }, C = (e) => e.replace(/\.+$/, ""), _ = (e) => {
+    const r2 = (performance.now() - e) / 1e3, t2 = Math.floor(r2 / 60), o = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o}s]` : `[${o}s]`;
+  }, N = I2.withGuide ?? settings.withGuide, P = (e = "") => {
+    d = true, M = block({ output: n3 }), s = C(e), w = performance.now(), N && n3.write(`${styleText2("gray", S_BAR)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T = setInterval(() => {
+      if (u3 && s === p)
+        return;
+      y(), p = s;
+      const o = k(E[r2]);
+      let v;
+      if (u3)
+        v = `${o}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o}  ${s} ${_(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n3.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d) return;
+    d = false, clearInterval(T), y();
+    const o = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n3.write(`${o}  ${s} ${_(w)}
+`) : n3.write(`${o}  ${s}
+`)), H(), M();
+  };
+  return {
+    start: P,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u2 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c = (t2, o) => t2.includes(`
+`) ? t2.split(`
+`).map((d) => o(d)).join(`
+`) : o(t2);
+var select = (t2) => {
+  const o = (n3, m) => {
+    if (n3 === void 0)
+      return "";
+    const s = n3.label ?? String(n3.value);
+    switch (m) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (i2) => styleText2("gray", i2))}${n3.hint ? ` ${styleText2("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (i2) => styleText2("dim", i2))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${styleText2("dim", `(${n3.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (i2) => styleText2(["strikethrough", "dim"], i2))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s, (i2) => styleText2("dim", i2))}`;
+    }
+  }, d = t2.showInstructions ?? true;
+  return new n$1({
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
+    render() {
+      const n3 = t2.withGuide ?? settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i2 = wrapTextWithPrefix(
+        t2.output,
+        t2.message,
+        s,
+        m
+      ), u3 = `${n3 ? `${styleText2("gray", S_BAR)}
+` : ""}${i2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+            t2.output,
+            o(this.options[this.cursor], "selected"),
+            r2
+          );
+          return `${u3}${a2}`;
+        }
+        case "cancel": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+            t2.output,
+            o(this.options[this.cursor], "cancelled"),
+            r2
+          );
+          return `${u3}${a2}${n3 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = n3 ? `${styleText2("cyan", S_BAR)}  ` : "", a2 = u3.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [styleText2("cyan", S_BAR_END)] : [], b = p.join(`
+`), f = p.length + 1;
+          return `${u3}${r2}${limitOptions({
+            output: t2.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t2.maxItems,
+            columnPadding: r2.length,
+            rowPadding: a2 + f,
+            style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${b}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (e) => new n2({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i2 = e?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, c2 = e.placeholder && e.placeholder.length > 0 ? (
+      // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
+      styleText2("inverse", e.placeholder[0]) + styleText2("dim", e.placeholder.slice(1))
+    ) : styleText2(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : c2, l2 = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n3 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r2 = i2 ? `${styleText2("yellow", S_BAR)}  ` : "", d = i2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r2}${o}
+${d}${n3}
+`;
+      }
+      case "submit": {
+        const n3 = l2 ? `  ${styleText2("dim", l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n3}`;
+      }
+      case "cancel": {
+        const n3 = l2 ? `  ${styleText2(["strikethrough", "dim"], l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n3}${l2.trim() ? `
+${r2}` : ""}`;
+      }
+      default: {
+        const n3 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", r2 = i2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${s}${n3}${o}
+${r2}
+`;
+      }
+    }
+  }
+}).prompt();
+
+// src/prompts.ts
+function isInteractive() {
+  return process.stdin.isTTY === true;
+}
+function handleCancel(value) {
+  if (isCancel(value)) {
+    cancel("Operation cancelled");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptText(message, options = {}) {
+  const result = await text({
+    message,
+    defaultValue: options.defaultValue,
+    placeholder: options.defaultValue,
+    validate: options.validate ? (value) => options.validate(value ?? "") : void 0
+  });
+  return handleCancel(result);
+}
+async function promptConfirm(message, initialValue = true) {
+  const result = await confirm({ message, initialValue });
+  return handleCancel(result);
+}
+async function promptSelect(message, items, defaultIndex = 0) {
+  if (items.length === 0) {
+    throw new Error("No items to select");
+  }
+  const result = await select({
+    message,
+    options: items.map((item) => ({
+      value: item.value,
+      label: item.label
+    })),
+    initialValue: items[defaultIndex]?.value
+  });
+  return handleCancel(result);
+}
+var spinner2 = spinner;
 
 // src/utils.ts
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
-import { basename, join, resolve } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync, writeFileSync } from "fs";
+import { basename, join as join2, resolve } from "path";
 var SAFE_DIR_ENTRIES = /* @__PURE__ */ new Set([
   ".claude",
   ".cursor",
@@ -60,7 +1294,7 @@ function isSafeEntry(name) {
   return SAFE_DIR_ENTRIES.has(name);
 }
 function findUnsafeEntries(dir) {
-  return readdirSync(dir).filter((entry) => !isSafeEntry(entry)).sort();
+  return readdirSync2(dir).filter((entry) => !isSafeEntry(entry)).sort();
 }
 function sanitizePackageName(raw) {
   return raw.toLowerCase().replace(/[^a-z0-9_.-]/g, "-").replace(/^[.-]+/, "").replace(/[.-]+$/, "") || "my-app";
@@ -84,15 +1318,15 @@ function deriveProjectInfo(rawName, cwd) {
   };
 }
 function updatePackageJson(projectPath, projectName) {
-  const packageJsonPath = join(projectPath, "package.json");
+  const packageJsonPath = join2(projectPath, "package.json");
   const packageJsonContent = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
   packageJsonContent.name = projectName;
   packageJsonContent.description = `MCP server: ${projectName}`;
   writeFileSync(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
 }
 function updateIndexTs(projectPath, projectName) {
-  const indexPath = join(projectPath, "index.ts");
-  if (!existsSync(indexPath)) {
+  const indexPath = join2(projectPath, "index.ts");
+  if (!existsSync2(indexPath)) {
     return;
   }
   let content = readFileSync(indexPath, "utf-8");
@@ -100,9 +1334,45 @@ function updateIndexTs(projectPath, projectName) {
   writeFileSync(indexPath, content);
 }
 
-// src/index.tsx
+// src/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
+var __dirname = dirname2(__filename);
+function parseCli(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      template: { type: "string", short: "t" },
+      "list-templates": { type: "boolean" },
+      install: { type: "boolean" },
+      skills: { type: "boolean" },
+      dev: { type: "boolean" },
+      canary: { type: "boolean" },
+      yarn: { type: "boolean" },
+      npm: { type: "boolean" },
+      pnpm: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "V" }
+    },
+    allowPositionals: true,
+    strict: false
+  });
+  const install = argv.includes("--install") ? true : argv.includes("--no-install") ? false : values.install;
+  const skills = argv.includes("--skills") ? true : argv.includes("--no-skills") ? false : values.skills;
+  return {
+    projectName: positionals[0],
+    options: {
+      template: values.template,
+      listTemplates: values["list-templates"],
+      install,
+      skills,
+      dev: values.dev,
+      canary: values.canary,
+      yarn: values.yarn,
+      npm: values.npm,
+      pnpm: values.pnpm
+    }
+  };
+}
 function runPackageManager(packageManager, args, cwd) {
   return new Promise((resolve2, reject) => {
     const child = spawn(packageManager, args, {
@@ -131,9 +1401,11 @@ function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
   if (userAgent.includes("yarn")) {
     return "yarn";
-  } else if (userAgent.includes("pnpm")) {
+  }
+  if (userAgent.includes("pnpm")) {
     return "pnpm";
-  } else if (userAgent.includes("npm")) {
+  }
+  if (userAgent.includes("npm")) {
     return "npm";
   }
   return null;
@@ -144,7 +1416,6 @@ function getDevCommand(packageManager) {
       return "yarn dev";
     case "pnpm":
       return "pnpm dev";
-    case "npm":
     default:
       return "npm run dev";
   }
@@ -155,7 +1426,6 @@ function getInstallCommand(packageManager) {
       return "yarn";
     case "pnpm":
       return "pnpm install";
-    case "npm":
     default:
       return "npm install";
   }
@@ -166,7 +1436,6 @@ function getInstallArgs(packageManager) {
       return ["install"];
     case "pnpm":
       return ["install"];
-    case "npm":
     default:
       return ["install"];
   }
@@ -193,112 +1462,92 @@ function sendInstallTelemetryEvent(agents, skills) {
   } catch {
   }
 }
-async function addSkillsToProject(projectPath) {
-  const REPO_OWNER = "mcp-use";
-  const REPO_NAME = "mcp-use";
-  const REPO_COMMIT = "main";
-  const tarballUrl = `https://codeload.github.com/${REPO_OWNER}/${REPO_NAME}/tar.gz/${REPO_COMMIT}`;
-  const tempDir = mkdtempSync(join2(tmpdir(), "mcp-use-skills-"));
+var SKILLS_REPO = "https://github.com/mcp-use/mcp-use.git";
+var SKILLS_SPARSE_PATH = "skills/mcp-apps-builder";
+var SKILLS_AGENT_DIRS = [".cursor", ".claude", ".agent"];
+var SKILLS_MANUAL_INSTALL_CMD = "npx --yes skills add mcp-use/mcp-use --yes --skill mcp-apps-builder -a cursor -a claude-code -a codex";
+function isGitAvailable() {
+  const result = spawnSync("git", ["--version"], {
+    stdio: "ignore",
+    shell: false
+  });
+  return result.status === 0 && !result.error;
+}
+function warnSkillsInstallFailed(missingGit) {
+  const reason = missingGit ? "Failed to install skills: git is not installed or not in PATH." : "Failed to install skills.";
+  console.log(yellow(`\u26A0\uFE0F  ${reason}`));
+  console.log(yellow(`   Run manually: ${SKILLS_MANUAL_INSTALL_CMD}`));
+}
+async function installSkills(projectPath) {
+  const tempDir = mkdtempSync(join3(tmpdir(), "mcp-use-skills-"));
+  const repoDir = join3(tempDir, "repo");
   try {
-    const response = await fetch(tarballUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to download tarball: ${response.statusText}`);
+    const clone = spawnSync(
+      "git",
+      [
+        "clone",
+        "--depth",
+        "1",
+        "--filter=blob:none",
+        "--sparse",
+        "--single-branch",
+        SKILLS_REPO,
+        repoDir
+      ],
+      { stdio: "ignore", shell: false }
+    );
+    if (clone.status !== 0 || clone.error) {
+      throw new Error("git clone failed");
     }
-    await pipeline(
-      Readable.fromWeb(response.body),
-      extract({
-        cwd: tempDir,
-        filter: (path) => path.includes("/skills/mcp-apps-builder/"),
-        strip: 1
-        // Removes 'mcp-use-{commit}/' prefix
-      })
+    const checkout = spawnSync(
+      "git",
+      ["sparse-checkout", "set", SKILLS_SPARSE_PATH],
+      { cwd: repoDir, stdio: "ignore", shell: false }
     );
-    const skillsPath = join2(tempDir, "skills");
-    if (!existsSync2(skillsPath)) {
-      throw new Error("Skills folder not found in tarball");
+    if (checkout.status !== 0 || checkout.error) {
+      throw new Error("git sparse-checkout failed");
     }
-    const presets = ["cursor", "claude-code", "codex"];
-    const presetFolders = {
-      cursor: ".cursor",
-      "claude-code": ".claude",
-      codex: ".agent"
-    };
-    for (const preset of presets) {
-      const folderName = presetFolders[preset];
-      const outputPath = join2(projectPath, folderName, "skills");
-      cpSync(skillsPath, outputPath, { recursive: true });
+    const skillSrc = join3(repoDir, SKILLS_SPARSE_PATH);
+    if (!existsSync3(skillSrc)) {
+      throw new Error("mcp-apps-builder skill not found in repository");
     }
-    const skillNames = readdirSync2(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-    sendInstallTelemetryEvent(presets.join(","), skillNames.join(","));
-  } catch (error) {
-    console.log(
-      chalk.yellow(
-        "\u26A0\uFE0F  Failed to download skills from GitHub. Continuing without skills..."
-      )
-    );
-    console.log(
-      chalk.yellow(
-        `   Error: ${error instanceof Error ? error.message : String(error)}`
-      )
-    );
-    return;
+    for (const agentDir of SKILLS_AGENT_DIRS) {
+      const dest = join3(projectPath, agentDir, "skills", "mcp-apps-builder");
+      mkdirSync(dirname2(dest), { recursive: true });
+      cpSync(skillSrc, dest, { recursive: true });
+    }
+    sendInstallTelemetryEvent("cursor,claude-code,codex", "mcp-apps-builder");
   } finally {
     rmSync(tempDir, { recursive: true, force: true });
   }
 }
-var program = new Command();
 function renderLogo() {
-  console.log(
-    chalk.white.bold(
-      " \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557         \u2588\u2588\u2557   \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557"
-    )
-  );
-  console.log(
-    chalk.white.bold(
-      " \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557        \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D"
-    )
-  );
-  console.log(
-    chalk.white.bold(
-      " \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551  \u2588\u2588\u2551       \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u2501\u2501\u2501\u2501  \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  "
-    )
-  );
-  console.log(
-    chalk.white.bold(
-      " \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551       \u2588\u2588\u2554\u2550\u2550\u2550\u255D   \u2501\u2501\u2501\u2501  \u2588\u2588\u2551   \u2588\u2588\u2551  \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551  \u2588\u2588\u2554\u2550\u2550\u255D  "
-    )
-  );
-  console.log(
-    chalk.white.bold(
-      " \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551             \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557"
-    )
-  );
-  console.log(
-    chalk.white.bold(
-      " \u255A\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D              \u255A\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
-    )
-  );
+  const lines = [
+    " \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557         \u2588\u2588\u2557   \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+    " \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557        \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D",
+    " \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551  \u2588\u2588\u2551       \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u2501\u2501\u2501\u2501  \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  ",
+    " \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551       \u2588\u2588\u2554\u2550\u2550\u2550\u255D   \u2501\u2501\u2501\u2501  \u2588\u2588\u2551   \u2588\u2588\u2551  \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551  \u2588\u2588\u2554\u2550\u2550\u255D  ",
+    " \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551             \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+    " \u255A\u2550\u255D     \u255A\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D              \u255A\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+  ];
+  for (const line of lines) {
+    console.log(whiteBold(line));
+  }
   console.log("");
-  console.log(chalk.gray.bold(" by Manufact"));
+  console.log(gray(bold(" by Manufact")));
 }
 var packageJson = JSON.parse(
-  readFileSync2(join2(__dirname, "../package.json"), "utf-8")
+  readFileSync2(join3(__dirname, "../package.json"), "utf-8")
 );
 function getCurrentPackageVersions(isDevelopment = false, useCanary = false) {
   const versions = {};
   try {
     if (isDevelopment) {
       versions["mcp-use"] = "workspace:*";
-      versions["@mcp-use/cli"] = "workspace:*";
-      versions["@mcp-use/inspector"] = "workspace:*";
     } else if (useCanary) {
       versions["mcp-use"] = "canary";
-      versions["@mcp-use/cli"] = "canary";
-      versions["@mcp-use/inspector"] = "canary";
     } else {
       versions["mcp-use"] = "latest";
-      versions["@mcp-use/cli"] = "latest";
-      versions["@mcp-use/inspector"] = "latest";
     }
   } catch (error) {
     if (process.env.NODE_ENV === "development") {
@@ -330,14 +1579,6 @@ function processTemplateFile(filePath, versions, isDevelopment = false, useCanar
       /"mcp-use": "\^[^"]+"/,
       '"mcp-use": "workspace:*"'
     );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/cli": "\^[^"]+"/,
-      '"@mcp-use/cli": "workspace:*"'
-    );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/inspector": "\^[^"]+"/,
-      '"@mcp-use/inspector": "workspace:*"'
-    );
   } else if (useCanary) {
     processedContent = processedContent.replace(
       /"mcp-use": "workspace:\*"/,
@@ -347,362 +1588,55 @@ function processTemplateFile(filePath, versions, isDevelopment = false, useCanar
       /"mcp-use": "\^[^"]+"/,
       `"mcp-use": "canary"`
     );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/cli": "workspace:\*"/,
-      `"@mcp-use/cli": "canary"`
-    );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/cli": "\^[^"]+"/,
-      `"@mcp-use/cli": "canary"`
-    );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/inspector": "workspace:\*"/,
-      `"@mcp-use/inspector": "canary"`
-    );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/inspector": "\^[^"]+"/,
-      `"@mcp-use/inspector": "canary"`
-    );
   } else {
     processedContent = processedContent.replace(
       /"mcp-use": "workspace:\*"/,
       `"mcp-use": "${versions["mcp-use"] || "latest"}"`
     );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/cli": "workspace:\*"/,
-      `"@mcp-use/cli": "${versions["@mcp-use/cli"] || "latest"}"`
-    );
-    processedContent = processedContent.replace(
-      /"@mcp-use\/inspector": "workspace:\*"/,
-      `"@mcp-use/inspector": "${versions["@mcp-use/inspector"] || "latest"}"`
-    );
   }
   return processedContent;
 }
 function getAvailableTemplates() {
-  const templatesDir = join2(__dirname, "templates");
-  if (!existsSync2(templatesDir)) {
+  const templatesDir = join3(__dirname, "templates");
+  if (!existsSync3(templatesDir)) {
     return [];
   }
-  return readdirSync2(templatesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
+  return readdirSync3(templatesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
 }
 function listTemplates() {
   console.log("");
   renderLogo();
   console.log("");
-  console.log(chalk.bold("Available Templates:"));
+  console.log(bold("Available Templates:"));
   console.log("");
-  const templatesDir = join2(__dirname, "templates");
+  const templatesDir = join3(__dirname, "templates");
   const availableTemplates = getAvailableTemplates();
   if (availableTemplates.length === 0) {
-    console.log(chalk.red("\u274C No templates found!"));
+    console.log(red("\u274C No templates found!"));
     return;
   }
   for (const template of availableTemplates) {
-    const packageJsonPath = join2(templatesDir, template, "package.json");
+    const packageJsonPath = join3(templatesDir, template, "package.json");
     let description = "MCP server template";
-    if (existsSync2(packageJsonPath)) {
+    if (existsSync3(packageJsonPath)) {
       try {
-        const packageJson2 = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
-        description = packageJson2.description || description;
-      } catch (error) {
+        const templatePackageJson = JSON.parse(
+          readFileSync2(packageJsonPath, "utf-8")
+        );
+        description = templatePackageJson.description || description;
+      } catch {
       }
     }
-    console.log(
-      chalk.cyan(`  ${template.padEnd(15)}`),
-      chalk.gray(description)
-    );
+    console.log(cyan(`  ${template.padEnd(15)}`), gray(description));
   }
   console.log("");
   console.log(
-    chalk.gray(
+    gray(
       "\u{1F4A1} Use with: npx create-mcp-use-app my-project --template <template>"
     )
   );
   console.log("");
 }
-program.name("create-mcp-use-app").description("Create a new MCP server project").version(packageJson.version).argument("[project-name]", "Name of the MCP server project").option(
-  "-t, --template <template>",
-  "Template to use (starter, mcp-ui, mcp-apps, blank) or GitHub repo URL (owner/repo or https://github.com/owner/repo)"
-).option("--list-templates", "List all available templates").option("--install", "Install dependencies after creating project").option("--no-install", "Skip installing dependencies").option("--skills", "Install skills for all agents").option("--no-skills", "Skip installing skills").option("--no-git", "Skip initializing a git repository").option("--dev", "Use workspace dependencies for development").option("--canary", "Use canary versions of packages").option("--yarn", "Use yarn as package manager").option("--npm", "Use npm as package manager").option("--pnpm", "Use pnpm as package manager").action(
-  async (projectName, options) => {
-    try {
-      if (options.listTemplates) {
-        listTemplates();
-        process.exit(0);
-      }
-      if (options.dev && options.canary) {
-        console.error(chalk.red("\u274C Cannot use --dev and --canary together"));
-        console.error(
-          chalk.yellow("   Please choose only one dependency mode")
-        );
-        process.exit(1);
-      }
-      let selectedTemplate = options.template;
-      console.log("");
-      renderLogo();
-      console.log("");
-      if (!projectName) {
-        projectName = await promptForProjectName();
-        console.log("");
-      }
-      if (!options.template && !selectedTemplate) {
-        selectedTemplate = await promptForTemplate();
-      }
-      if (!selectedTemplate) {
-        selectedTemplate = "starter";
-      }
-      const trimmedProjectName = projectName.trim();
-      if (!trimmedProjectName) {
-        console.error(chalk.red("\u274C Project name cannot be empty"));
-        process.exit(1);
-      }
-      const { useCurrentDir, projectPath, displayName, packageName } = deriveProjectInfo(trimmedProjectName, process.cwd());
-      if (useCurrentDir) {
-        const unsafeEntries = findUnsafeEntries(projectPath);
-        if (unsafeEntries.length > 0) {
-          console.error(
-            chalk.red(
-              "\u274C Cannot initialize here \u2014 these entries would clash with the template:"
-            )
-          );
-          for (const entry of unsafeEntries) {
-            console.error(chalk.red(`   \u2022 ${entry}`));
-          }
-          console.error("");
-          console.error(
-            chalk.yellow(
-              "   Remove these files, or pass a project name to scaffold into a new subdirectory instead."
-            )
-          );
-          process.exit(1);
-        }
-      } else {
-        if (trimmedProjectName.includes("..") || trimmedProjectName.includes("/") || trimmedProjectName.includes("\\")) {
-          console.error(
-            chalk.red(
-              '\u274C Project name cannot contain path separators or ".."'
-            )
-          );
-          console.error(
-            chalk.yellow('   Use simple names like "my-mcp-server"')
-          );
-          process.exit(1);
-        }
-        const protectedNames = [
-          "node_modules",
-          ".git",
-          ".env",
-          "package.json",
-          "src",
-          "dist"
-        ];
-        if (protectedNames.includes(trimmedProjectName.toLowerCase())) {
-          console.error(
-            chalk.red(`\u274C Cannot use protected name "${trimmedProjectName}"`)
-          );
-          console.error(
-            chalk.yellow("   Please choose a different project name")
-          );
-          process.exit(1);
-        }
-        if (existsSync2(projectPath)) {
-          console.error(
-            chalk.red(`\u274C Directory "${trimmedProjectName}" already exists!`)
-          );
-          console.error(
-            chalk.yellow(
-              "   Please choose a different name or remove the existing directory"
-            )
-          );
-          process.exit(1);
-        }
-        mkdirSync(projectPath, { recursive: true });
-      }
-      console.log(chalk.cyan(`\u{1F680} Creating MCP server "${displayName}"...`));
-      const validatedTemplate = validateTemplateName(selectedTemplate);
-      const versions = getCurrentPackageVersions(options.dev, options.canary);
-      await copyTemplate(
-        projectPath,
-        validatedTemplate,
-        versions,
-        options.dev,
-        options.canary
-      );
-      updatePackageJson(projectPath, packageName);
-      updateIndexTs(projectPath, packageName);
-      if (options.template !== void 0) {
-        if (options.install === void 0) {
-          options.install = false;
-        }
-        if (options.skills === void 0) {
-          options.skills = true;
-        }
-      }
-      console.log("");
-      const shouldInstallSkills = options.skills !== void 0 ? options.skills : await promptForSkillsPresets();
-      let skillsInstalled = false;
-      if (shouldInstallSkills) {
-        console.log("");
-        console.log(chalk.cyan("\u{1F4DA} Installing skills..."));
-        try {
-          await addSkillsToProject(projectPath);
-          skillsInstalled = true;
-          console.log(chalk.green("\u2705 Skills installed successfully!"));
-        } catch (err) {
-          console.log(
-            chalk.yellow(
-              "\u26A0\uFE0F  Skills install failed. Run `npx skills add mcp-use/mcp-use` manually in root directory."
-            )
-          );
-        }
-      }
-      let usedPackageManager = "npm";
-      if (options.yarn) {
-        usedPackageManager = "yarn";
-      } else if (options.npm) {
-        usedPackageManager = "npm";
-      } else if (options.pnpm) {
-        usedPackageManager = "pnpm";
-      } else {
-        const detected = detectPackageManager();
-        if (detected) {
-          usedPackageManager = detected;
-        } else {
-          const defaultOrder = ["npm", "pnpm", "yarn"];
-          usedPackageManager = defaultOrder[0];
-        }
-      }
-      console.log("");
-      const shouldInstall = options.install !== void 0 ? options.install : await promptForInstall(usedPackageManager);
-      if (shouldInstall) {
-        console.log("");
-        console.log(chalk.cyan("\u{1F4E6} Installing dependencies..."));
-        console.log("");
-        const isKnownManager = options.yarn || options.npm || options.pnpm || detectPackageManager();
-        const managersToTry = isKnownManager ? [usedPackageManager] : ["npm", "pnpm", "yarn"];
-        let installed = false;
-        for (const pm of managersToTry) {
-          const spinner = ora(`Installing packages with ${pm}...`).start();
-          try {
-            await runPackageManager(pm, getInstallArgs(pm), projectPath);
-            usedPackageManager = pm;
-            spinner.succeed(`Packages installed successfully with ${pm}`);
-            installed = true;
-            break;
-          } catch (err) {
-            const remaining = managersToTry.slice(
-              managersToTry.indexOf(pm) + 1
-            );
-            if (remaining.length > 0) {
-              spinner.warn(`${pm} not available, trying ${remaining[0]}...`);
-            } else {
-              spinner.fail("Package installation failed");
-              if (err instanceof Error) {
-                console.error(chalk.red(err.message));
-              }
-            }
-          }
-        }
-        if (!installed) {
-          console.log(
-            '\u26A0\uFE0F  Please run "npm install", "yarn install", or "pnpm install" manually'
-          );
-        }
-      }
-      console.log("");
-      console.log(chalk.green("\u2705 MCP server created successfully!"));
-      if (options.dev) {
-        console.log(
-          chalk.yellow("\u{1F527} Development mode: Using workspace dependencies")
-        );
-      } else if (options.canary) {
-        console.log(
-          chalk.cyan("\u{1F680} Canary mode: Using canary versions of packages")
-        );
-      }
-      console.log("");
-      console.log(chalk.bold("\u{1F4C1} Project structure:"));
-      console.log(`   ${useCurrentDir ? "." : displayName}/`);
-      if (skillsInstalled) {
-        console.log("   \u251C\u2500\u2500 .agent/skills/");
-        console.log("   \u251C\u2500\u2500 .claude/skills/");
-        console.log("   \u251C\u2500\u2500 .cursor/skills/");
-      }
-      if (validatedTemplate === "blank") {
-        console.log("   \u251C\u2500\u2500 public/");
-        console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
-        console.log("   \u251C\u2500\u2500 package.json");
-        console.log("   \u251C\u2500\u2500 tsconfig.json");
-        console.log("   \u2514\u2500\u2500 README.md");
-      } else if (validatedTemplate === "mcp-apps") {
-        console.log("   \u251C\u2500\u2500 public/");
-        console.log("   \u251C\u2500\u2500 resources/");
-        console.log("   \u2502   \u2514\u2500\u2500 product-search-result/");
-        console.log("   \u2502       \u2514\u2500\u2500 widget.tsx");
-        console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
-        console.log("   \u251C\u2500\u2500 package.json");
-        console.log("   \u251C\u2500\u2500 tsconfig.json");
-        console.log("   \u2514\u2500\u2500 README.md");
-      } else if (validatedTemplate === "starter") {
-        console.log("   \u251C\u2500\u2500 public/");
-        console.log("   \u251C\u2500\u2500 resources/");
-        console.log("   \u2502   \u2514\u2500\u2500 display-weather.tsx");
-        console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
-        console.log("   \u251C\u2500\u2500 package.json");
-        console.log("   \u251C\u2500\u2500 tsconfig.json");
-        console.log("   \u2514\u2500\u2500 README.md");
-      } else {
-        console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
-        console.log("   \u251C\u2500\u2500 package.json");
-        console.log("   \u251C\u2500\u2500 tsconfig.json");
-        console.log("   \u2514\u2500\u2500 README.md");
-      }
-      console.log("");
-      console.log(chalk.bold("\u{1F680} To get started:"));
-      if (!useCurrentDir) {
-        console.log(chalk.cyan(`   cd ${displayName}`));
-      }
-      if (!shouldInstall) {
-        console.log(
-          chalk.cyan(`   ${getInstallCommand(usedPackageManager)}`)
-        );
-      }
-      console.log(chalk.cyan(`   ${getDevCommand(usedPackageManager)}`));
-      console.log("");
-      console.log(chalk.bold("\u{1F4E4} To deploy:"));
-      console.log(
-        chalk.cyan(
-          `   ${usedPackageManager === "yarn" ? "yarn" : usedPackageManager === "pnpm" ? "pnpm" : "npm run"} deploy`
-        )
-      );
-      console.log("");
-      if (options.dev) {
-        console.log(
-          chalk.yellow(
-            "\u{1F4A1} Development mode: Your project uses workspace dependencies"
-          )
-        );
-        console.log(
-          chalk.yellow(
-            "   Make sure you're in the mcp-use workspace root for development"
-          )
-        );
-        console.log("");
-      }
-      console.log(chalk.cyan("\u{1F4DA} Learn more: https://manufact.com/docs"));
-      console.log(chalk.gray("\u{1F4AC} For feedback and bug reporting visit:"));
-      console.log(
-        chalk.gray(
-          "   https://github.com/mcp-use/mcp-use or https://manufact.com"
-        )
-      );
-    } catch (error) {
-      console.error("\u274C Error creating MCP server:", error);
-      process.exit(1);
-    }
-  }
-);
 function parseGitHubRepoUrl(url) {
   const trimmed = url.trim();
   let match = trimmed.match(
@@ -758,17 +1692,16 @@ async function cloneGitHubRepo(repoInfo, tempDir) {
     shell: false
   });
   if (versionCheck.status !== 0 || versionCheck.error) {
+    console.error(red("\u274C Git is not installed or not available in PATH"));
     console.error(
-      chalk.red("\u274C Git is not installed or not available in PATH")
-    );
-    console.error(
-      chalk.yellow("   Please install Git to use GitHub repository templates")
+      yellow("   Please install Git to use GitHub repository templates")
     );
     process.exit(1);
   }
   const repoUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}.git`;
   const branch = repoInfo.branch || "main";
-  const spinner = ora(`Cloning repository from GitHub...`).start();
+  const s = spinner2();
+  s.start("Cloning repository from GitHub...");
   const cloneWithBranch = (branchName) => {
     const result = spawnSync(
       "git",
@@ -789,33 +1722,33 @@ async function cloneGitHubRepo(repoInfo, tempDir) {
   };
   const cloneResult = cloneWithBranch(branch);
   if (cloneResult.success) {
-    spinner.succeed("Repository cloned successfully");
+    s.stop("Repository cloned successfully");
     return tempDir;
   }
   if (!repoInfo.branch) {
-    spinner.text = `Branch "${branch}" not found, trying "main"...`;
+    s.message(`Branch "${branch}" not found, trying "main"...`);
     const mainResult = cloneWithBranch("main");
     if (mainResult.success) {
-      spinner.succeed("Repository cloned successfully (using main branch)");
+      s.stop("Repository cloned successfully (using main branch)");
       return tempDir;
     }
-    spinner.text = `Branch "main" not found, trying "master"...`;
+    s.message('Branch "main" not found, trying "master"...');
     const masterResult = cloneWithBranch("master");
     if (masterResult.success) {
-      spinner.succeed("Repository cloned successfully (using master branch)");
+      s.stop("Repository cloned successfully (using master branch)");
       return tempDir;
     }
   }
-  spinner.fail("Failed to clone repository");
-  console.error(chalk.red(`\u274C Error cloning repository: ${repoUrl}`));
+  s.error("Failed to clone repository");
+  console.error(red(`\u274C Error cloning repository: ${repoUrl}`));
   if (repoInfo.branch) {
-    console.error(chalk.yellow(`   Branch "${repoInfo.branch}" may not exist`));
+    console.error(yellow(`   Branch "${repoInfo.branch}" may not exist`));
   }
   const errorMessage = cloneResult.error?.message || "Unknown error";
   if (errorMessage.includes("not found")) {
-    console.error(chalk.yellow(`   Repository may not exist or is private`));
+    console.error(yellow("   Repository may not exist or is private"));
   } else {
-    console.error(chalk.yellow(`   ${errorMessage}`));
+    console.error(yellow(`   ${errorMessage}`));
   }
   throw cloneResult.error || new Error("Failed to clone repository");
 }
@@ -826,20 +1759,19 @@ function validateTemplateName(template) {
   }
   const aliases = {
     "apps-sdk": "mcp-apps"
-    // Silent redirect for backward compatibility
   };
   const resolvedTemplate = aliases[sanitized] || sanitized;
   if (resolvedTemplate.includes("..") || resolvedTemplate.includes("/") || resolvedTemplate.includes("\\")) {
-    console.error(chalk.red("\u274C Invalid template name"));
+    console.error(red("\u274C Invalid template name"));
     console.error(
-      chalk.yellow("   Template name cannot contain path separators")
+      yellow("   Template name cannot contain path separators")
     );
     process.exit(1);
   }
   if (!/^[a-zA-Z0-9_-]+$/.test(resolvedTemplate)) {
-    console.error(chalk.red("\u274C Invalid template name"));
+    console.error(red("\u274C Invalid template name"));
     console.error(
-      chalk.yellow(
+      yellow(
         "   Template name can only contain letters, numbers, hyphens, and underscores"
       )
     );
@@ -850,7 +1782,7 @@ function validateTemplateName(template) {
 async function copyTemplate(projectPath, template, versions, isDevelopment = false, useCanary = false) {
   const repoInfo = parseGitHubRepoUrl(template);
   if (repoInfo) {
-    const tempDir = mkdtempSync(join2(tmpdir(), "create-mcp-use-app-"));
+    const tempDir = mkdtempSync(join3(tmpdir(), "create-mcp-use-app-"));
     try {
       await cloneGitHubRepo(repoInfo, tempDir);
       copyDirectoryWithProcessing(
@@ -863,7 +1795,7 @@ async function copyTemplate(projectPath, template, versions, isDevelopment = fal
     } finally {
       try {
         rmSync(tempDir, { recursive: true, force: true });
-      } catch (error) {
+      } catch {
         if (process.env.NODE_ENV === "development") {
           console.warn(
             `Warning: Failed to clean up temp directory: ${tempDir}`
@@ -873,12 +1805,12 @@ async function copyTemplate(projectPath, template, versions, isDevelopment = fal
     }
     return;
   }
-  const templatePath = join2(__dirname, "templates", template);
-  if (!existsSync2(templatePath)) {
-    console.error(chalk.red(`\u274C Template "${template}" not found!`));
-    const templatesDir = join2(__dirname, "templates");
-    if (existsSync2(templatesDir)) {
-      const availableTemplates = readdirSync2(templatesDir, {
+  const templatePath = join3(__dirname, "templates", template);
+  if (!existsSync3(templatePath)) {
+    console.error(red(`\u274C Template "${template}" not found!`));
+    const templatesDir = join3(__dirname, "templates");
+    if (existsSync3(templatesDir)) {
+      const availableTemplates = readdirSync3(templatesDir, {
         withFileTypes: true
       }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
       console.log(`Available templates: ${availableTemplates.join(", ")}`);
@@ -905,14 +1837,14 @@ async function copyTemplate(projectPath, template, versions, isDevelopment = fal
   );
 }
 function copyDirectoryWithProcessing(src, dest, versions, isDevelopment, useCanary = false) {
-  const entries = readdirSync2(src, { withFileTypes: true });
+  const entries = readdirSync3(src, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git") {
       continue;
     }
-    const srcPath = join2(src, entry.name);
+    const srcPath = join3(src, entry.name);
     const destName = entry.name === "gitignore" ? ".gitignore" : entry.name;
-    const destPath = join2(dest, destName);
+    const destPath = join3(dest, destName);
     if (entry.isDirectory()) {
       mkdirSync(destPath, { recursive: true });
       copyDirectoryWithProcessing(
@@ -922,187 +1854,394 @@ function copyDirectoryWithProcessing(src, dest, versions, isDevelopment, useCana
         isDevelopment,
         useCanary
       );
+    } else if (entry.name === "package.json" || entry.name.endsWith(".json")) {
+      const processedContent = processTemplateFile(
+        srcPath,
+        versions,
+        isDevelopment,
+        useCanary
+      );
+      writeFileSync2(destPath, processedContent);
     } else {
-      if (entry.name === "package.json" || entry.name.endsWith(".json")) {
-        const processedContent = processTemplateFile(
-          srcPath,
-          versions,
-          isDevelopment,
-          useCanary
-        );
-        writeFileSync2(destPath, processedContent);
-      } else {
-        copyFileSync(srcPath, destPath);
-      }
+      copyFileSync(srcPath, destPath);
     }
   }
 }
-function InstallPrompt({
-  packageManager,
-  onSubmit
-}) {
-  const [value, setValue] = useState("");
-  const handleSubmit = (val) => {
-    const trimmed = val.trim().toLowerCase();
-    if (trimmed === "" || trimmed === "y" || trimmed === "yes") {
-      onSubmit(true);
-    } else if (trimmed === "n" || trimmed === "no") {
-      onSubmit(false);
-    }
-  };
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Install dependencies with ", packageManager, "? (Y/n)")), /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "\u276F "), /* @__PURE__ */ React.createElement(TextInput, { value, onChange: setValue, onSubmit: handleSubmit })));
-}
-async function promptForInstall(packageManager) {
-  return new Promise((resolve2) => {
-    const { unmount } = render(
-      /* @__PURE__ */ React.createElement(
-        InstallPrompt,
-        {
-          packageManager,
-          onSubmit: (install) => {
-            unmount();
-            resolve2(install);
-          }
-        }
-      )
-    );
-  });
-}
-function SkillsPresetPrompt({
-  onSubmit
-}) {
-  const [value, setValue] = useState("");
-  const handleSubmit = (val) => {
-    const trimmed = val.trim().toLowerCase();
-    if (trimmed === "" || trimmed === "y" || trimmed === "yes") {
-      onSubmit(true);
-    } else if (trimmed === "n" || trimmed === "no") {
-      onSubmit(false);
+function getTemplateItems() {
+  const templatesDir = join3(__dirname, "templates");
+  const availableTemplates = getAvailableTemplates();
+  return availableTemplates.map((template) => {
+    const packageJsonPath = join3(templatesDir, template, "package.json");
+    let description = "MCP server template";
+    if (existsSync3(packageJsonPath)) {
+      try {
+        const templatePackageJson = JSON.parse(
+          readFileSync2(packageJsonPath, "utf-8")
+        );
+        description = templatePackageJson.description || description;
+      } catch {
+      }
     }
-  };
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Install AI coding skills for Cursor, Claude Code, and Codex? (Recommended) (Y/n)")), /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "\u276F "), /* @__PURE__ */ React.createElement(TextInput, { value, onChange: setValue, onSubmit: handleSubmit })));
-}
-async function promptForSkillsPresets() {
-  return new Promise((resolve2) => {
-    const { unmount } = render(
-      /* @__PURE__ */ React.createElement(
-        SkillsPresetPrompt,
-        {
-          onSubmit: (presets) => {
-            unmount();
-            resolve2(presets);
-          }
-        }
-      )
-    );
+    return {
+      label: `${template} - ${description}`,
+      value: template
+    };
   });
 }
-function ProjectNameInput({ onSubmit }) {
-  const [value, setValue] = useState("");
-  const [error, setError] = useState("");
-  const handleSubmit = (val) => {
-    const trimmed = val.trim();
-    if (!trimmed) {
-      setError("Project name is required");
-      return;
-    }
-    if (trimmed === ".") {
-      const unsafeEntries = findUnsafeEntries(process.cwd());
-      if (unsafeEntries.length > 0) {
-        const list = unsafeEntries.map((entry) => `   \u2022 ${entry}`).join("\n");
-        setError(
-          `Cannot initialize here \u2014 these entries would clash with the template:
+async function promptForProjectName() {
+  return promptText("What is your project name?", {
+    validate: (value) => {
+      if (!value) {
+        return "Project name is required";
+      }
+      if (value === ".") {
+        const unsafeEntries = findUnsafeEntries(process.cwd());
+        if (unsafeEntries.length > 0) {
+          const list = unsafeEntries.map((entry) => `   \u2022 ${entry}`).join("\n");
+          return `Cannot initialize here \u2014 these entries would clash with the template:
 ${list}
 
-Remove these files, or pick a project name to scaffold into a subdirectory.`
-        );
-        return;
+Remove these files, or pick a project name to scaffold into a subdirectory.`;
+        }
+        return void 0;
       }
-    } else {
-      if (!/^[a-zA-Z0-9-_]+$/.test(trimmed)) {
-        setError(
-          "Project name can only contain letters, numbers, hyphens, and underscores"
-        );
-        return;
+      if (!/^[a-zA-Z0-9-_]+$/.test(value)) {
+        return "Project name can only contain letters, numbers, hyphens, and underscores";
       }
-      if (existsSync2(join2(process.cwd(), trimmed))) {
-        setError(
-          `Directory "${trimmed}" already exists! Please choose a different name.`
-        );
-        return;
+      if (existsSync3(join3(process.cwd(), value))) {
+        return `Directory "${value}" already exists! Please choose a different name.`;
       }
+      return void 0;
     }
-    onSubmit(trimmed);
-  };
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "What is your project name?")), /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "\u276F "), /* @__PURE__ */ React.createElement(TextInput, { value, onChange: setValue, onSubmit: handleSubmit })), error && /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u2716 ", error)));
+  });
 }
-async function promptForProjectName() {
-  return new Promise((resolve2) => {
-    const { unmount } = render(
-      /* @__PURE__ */ React.createElement(
-        ProjectNameInput,
-        {
-          onSubmit: (name) => {
-            unmount();
-            resolve2(name);
-          }
-        }
-      )
+async function promptForTemplate() {
+  const items = getTemplateItems();
+  if (items.length === 0) {
+    console.error(
+      red(`\u274C No templates found in: ${join3(__dirname, "templates")}`)
     );
-  });
+    process.exit(1);
+  }
+  const defaultIndex = Math.max(
+    0,
+    items.findIndex((item) => item.value === "mcp-apps")
+  );
+  return promptSelect("Select a template:", items, defaultIndex);
 }
-function TemplateSelector({
-  onSelect
-}) {
-  const templatesDir = join2(__dirname, "templates");
-  if (!existsSync2(templatesDir)) {
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u274C Templates directory not found at: ", templatesDir), /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, " __dirname: ", __dirname));
-  }
-  const availableTemplates = readdirSync2(templatesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
-  if (availableTemplates.length === 0) {
-    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u274C No templates found in: ", templatesDir));
+function printHelp() {
+  console.log(`Usage: create-mcp-use-app [project-name] [options]
+
+Create a new MCP server project.
+
+Arguments:
+  project-name              Name of the MCP server project
+
+Options:
+  -t, --template <template> Template to use or GitHub repo URL
+  --list-templates          List all available templates
+  --install                 Install dependencies after creating project
+  --no-install              Skip installing dependencies
+  --skills                  Install skills for all agents
+  --no-skills               Skip installing skills
+  --no-git                  Skip initializing a git repository
+  --dev                     Use workspace dependencies for development
+  --canary                  Use canary versions of packages
+  --yarn                    Use yarn as package manager
+  --npm                     Use npm as package manager
+  --pnpm                    Use pnpm as package manager
+  -h, --help                Display help
+  -V, --version             Display version`);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const { projectName: initialProjectName, options } = parseCli(argv);
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printHelp();
+    return;
   }
-  const items = availableTemplates.map((template) => {
-    const packageJsonPath = join2(templatesDir, template, "package.json");
-    let description = "MCP server template";
-    if (existsSync2(packageJsonPath)) {
+  if (argv.includes("--version") || argv.includes("-V")) {
+    console.log(packageJson.version);
+    return;
+  }
+  if (options.listTemplates) {
+    listTemplates();
+    return;
+  }
+  if (options.dev && options.canary) {
+    console.error(red("\u274C Cannot use --dev and --canary together"));
+    console.error(yellow("   Please choose only one dependency mode"));
+    process.exit(1);
+  }
+  let projectName = initialProjectName;
+  let selectedTemplate = options.template;
+  const interactive = isInteractive();
+  console.log("");
+  renderLogo();
+  console.log("");
+  if (!projectName) {
+    if (!interactive) {
+      console.error(
+        red("\u274C Project name is required in non-interactive mode")
+      );
+      process.exit(1);
+    }
+    projectName = await promptForProjectName();
+    console.log("");
+  }
+  if (!selectedTemplate) {
+    if (interactive) {
+      selectedTemplate = await promptForTemplate();
+    } else {
+      selectedTemplate = "starter";
+    }
+  }
+  const trimmedProjectName = projectName.trim();
+  if (!trimmedProjectName) {
+    console.error(red("\u274C Project name cannot be empty"));
+    process.exit(1);
+  }
+  const { useCurrentDir, projectPath, displayName, packageName } = deriveProjectInfo(trimmedProjectName, process.cwd());
+  if (useCurrentDir) {
+    const unsafeEntries = findUnsafeEntries(projectPath);
+    if (unsafeEntries.length > 0) {
+      console.error(
+        red(
+          "\u274C Cannot initialize here \u2014 these entries would clash with the template:"
+        )
+      );
+      for (const entry of unsafeEntries) {
+        console.error(red(`   \u2022 ${entry}`));
+      }
+      console.error("");
+      console.error(
+        yellow(
+          "   Remove these files, or pass a project name to scaffold into a new subdirectory instead."
+        )
+      );
+      process.exit(1);
+    }
+  } else {
+    if (trimmedProjectName.includes("..") || trimmedProjectName.includes("/") || trimmedProjectName.includes("\\")) {
+      console.error(
+        red('\u274C Project name cannot contain path separators or ".."')
+      );
+      console.error(yellow('   Use simple names like "my-mcp-server"'));
+      process.exit(1);
+    }
+    const protectedNames = [
+      "node_modules",
+      ".git",
+      ".env",
+      "package.json",
+      "src",
+      "dist"
+    ];
+    if (protectedNames.includes(trimmedProjectName.toLowerCase())) {
+      console.error(
+        red(`\u274C Cannot use protected name "${trimmedProjectName}"`)
+      );
+      console.error(yellow("   Please choose a different project name"));
+      process.exit(1);
+    }
+    if (existsSync3(projectPath)) {
+      console.error(
+        red(`\u274C Directory "${trimmedProjectName}" already exists!`)
+      );
+      console.error(
+        yellow(
+          "   Please choose a different name or remove the existing directory"
+        )
+      );
+      process.exit(1);
+    }
+    mkdirSync(projectPath, { recursive: true });
+  }
+  console.log(cyan(`\u{1F680} Creating MCP server "${displayName}"...`));
+  const validatedTemplate = validateTemplateName(selectedTemplate);
+  const versions = getCurrentPackageVersions(options.dev, options.canary);
+  await copyTemplate(
+    projectPath,
+    validatedTemplate,
+    versions,
+    options.dev,
+    options.canary
+  );
+  updatePackageJson(projectPath, packageName);
+  updateIndexTs(projectPath, packageName);
+  let install = options.install;
+  let skills = options.skills;
+  if (options.template !== void 0) {
+    if (install === void 0) {
+      install = false;
+    }
+    if (skills === void 0) {
+      skills = true;
+    }
+  } else if (!interactive) {
+    if (install === void 0) {
+      install = false;
+    }
+    if (skills === void 0) {
+      skills = false;
+    }
+  }
+  console.log("");
+  const shouldInstallSkills = skills !== void 0 ? skills : interactive ? await promptConfirm(
+    "Install AI coding skills for Cursor, Claude Code, and Codex? (Recommended)",
+    true
+  ) : false;
+  let skillsInstalled = false;
+  if (shouldInstallSkills) {
+    console.log("");
+    const s = spinner2();
+    s.start("Installing skills...");
+    if (!isGitAvailable()) {
+      s.stop("Skills install skipped");
+      warnSkillsInstallFailed(true);
+    } else {
       try {
-        const packageJson2 = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
-        description = packageJson2.description || description;
-      } catch (error) {
+        await installSkills(projectPath);
+        skillsInstalled = true;
+        s.stop("Skills installed successfully!");
+      } catch {
+        s.stop("Skills install failed");
+        warnSkillsInstallFailed(false);
       }
     }
-    return {
-      label: `${template} - ${description}`,
-      value: template
-    };
-  });
-  const defaultIndex = items.findIndex((item) => item.value === "mcp-apps");
-  const initialIndex = defaultIndex >= 0 ? defaultIndex : 0;
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true }, "Select a template:")), /* @__PURE__ */ React.createElement(
-    SelectInput,
-    {
-      items,
-      initialIndex,
-      onSelect: (item) => onSelect(item.value),
-      indicatorComponent: ({ isSelected }) => /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, isSelected ? "\u276F " : "  "),
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "cyan" : void 0 }, label)
+  }
+  let usedPackageManager = "npm";
+  if (options.yarn) {
+    usedPackageManager = "yarn";
+  } else if (options.npm) {
+    usedPackageManager = "npm";
+  } else if (options.pnpm) {
+    usedPackageManager = "pnpm";
+  } else {
+    const detected = detectPackageManager();
+    if (detected) {
+      usedPackageManager = detected;
     }
-  ));
-}
-async function promptForTemplate() {
-  return new Promise((resolve2) => {
-    const { unmount } = render(
-      /* @__PURE__ */ React.createElement(
-        TemplateSelector,
-        {
-          onSelect: (template) => {
-            unmount();
-            resolve2(template);
+  }
+  console.log("");
+  const shouldInstall = install !== void 0 ? install : interactive ? await promptConfirm(
+    `Install dependencies with ${usedPackageManager}?`,
+    true
+  ) : false;
+  if (shouldInstall) {
+    console.log("");
+    console.log(cyan("\u{1F4E6} Installing dependencies..."));
+    console.log("");
+    const isKnownManager = options.yarn || options.npm || options.pnpm || detectPackageManager();
+    const managersToTry = isKnownManager ? [usedPackageManager] : ["npm", "pnpm", "yarn"];
+    let installed = false;
+    for (const pm of managersToTry) {
+      const s = spinner2();
+      s.start(`Installing packages with ${pm}...`);
+      try {
+        await runPackageManager(pm, getInstallArgs(pm), projectPath);
+        usedPackageManager = pm;
+        s.stop(`Packages installed successfully with ${pm}`);
+        installed = true;
+        break;
+      } catch (err) {
+        const remaining = managersToTry.slice(managersToTry.indexOf(pm) + 1);
+        if (remaining.length > 0) {
+          s.stop(`${pm} not available, trying ${remaining[0]}...`);
+        } else {
+          s.error("Package installation failed");
+          if (err instanceof Error) {
+            console.error(red(err.message));
           }
         }
+      }
+    }
+    if (!installed) {
+      console.log(
+        '\u26A0\uFE0F  Please run "npm install", "yarn install", or "pnpm install" manually'
+      );
+    }
+  }
+  console.log("");
+  console.log(green("\u2705 MCP server created successfully!"));
+  if (options.dev) {
+    console.log(
+      yellow("\u{1F527} Development mode: Using workspace dependencies")
+    );
+  } else if (options.canary) {
+    console.log(cyan("\u{1F680} Canary mode: Using canary versions of packages"));
+  }
+  console.log("");
+  console.log(bold("\u{1F4C1} Project structure:"));
+  console.log(`   ${useCurrentDir ? "." : displayName}/`);
+  if (skillsInstalled) {
+    console.log("   \u251C\u2500\u2500 .agent/skills/");
+    console.log("   \u251C\u2500\u2500 .claude/skills/");
+    console.log("   \u251C\u2500\u2500 .cursor/skills/");
+  }
+  if (validatedTemplate === "blank") {
+    console.log("   \u251C\u2500\u2500 public/");
+    console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
+    console.log("   \u251C\u2500\u2500 package.json");
+    console.log("   \u251C\u2500\u2500 tsconfig.json");
+    console.log("   \u2514\u2500\u2500 README.md");
+  } else if (validatedTemplate === "mcp-apps") {
+    console.log("   \u251C\u2500\u2500 resources/");
+    console.log("   \u2502   \u2514\u2500\u2500 product-search-result/");
+    console.log("   \u2502       \u2514\u2500\u2500 view.tsx");
+    console.log("   \u251C\u2500\u2500 tools.d.ts");
+    console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
+    console.log("   \u251C\u2500\u2500 package.json");
+    console.log("   \u251C\u2500\u2500 tsconfig.json");
+    console.log("   \u2514\u2500\u2500 README.md");
+  } else if (validatedTemplate === "starter") {
+    console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
+    console.log("   \u251C\u2500\u2500 package.json");
+    console.log("   \u251C\u2500\u2500 tsconfig.json");
+    console.log("   \u2514\u2500\u2500 README.md");
+  } else {
+    console.log("   \u251C\u2500\u2500 index.ts (server entry point)");
+    console.log("   \u251C\u2500\u2500 package.json");
+    console.log("   \u251C\u2500\u2500 tsconfig.json");
+    console.log("   \u2514\u2500\u2500 README.md");
+  }
+  console.log("");
+  console.log(bold("\u{1F680} To get started:"));
+  if (!useCurrentDir) {
+    console.log(cyan(`   cd ${displayName}`));
+  }
+  if (!shouldInstall) {
+    console.log(cyan(`   ${getInstallCommand(usedPackageManager)}`));
+  }
+  console.log(cyan(`   ${getDevCommand(usedPackageManager)}`));
+  console.log("");
+  console.log(bold("\u{1F4E4} To deploy:"));
+  console.log(
+    cyan(
+      `   ${usedPackageManager === "yarn" ? "yarn" : usedPackageManager === "pnpm" ? "pnpm" : "npm run"} deploy`
+    )
+  );
+  console.log("");
+  if (options.dev) {
+    console.log(
+      yellow(
+        "\u{1F4A1} Development mode: Your project uses workspace dependencies"
       )
     );
-  });
+    console.log(
+      yellow(
+        "   Make sure you're in the mcp-use workspace root for development"
+      )
+    );
+    console.log("");
+  }
+  console.log(cyan("\u{1F4DA} Learn more: https://manufact.com/docs"));
+  console.log(gray("\u{1F4AC} For feedback and bug reporting visit:"));
+  console.log(
+    gray("   https://github.com/mcp-use/mcp-use or https://manufact.com")
+  );
 }
-program.parse();
+main().catch((error) => {
+  console.error("\u274C Error creating MCP server:", error);
+  process.exit(1);
+});