@mcp-use/cli 2.13.10 → 2.14.0

package/dist/index.cjs

@@ -523,13 +523,13 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/index.ts
-var import_commander3 = require("commander");
+var import_commander4 = require("commander");
 var import_config5 = require("dotenv/config");
 var import_node_child_process9 = require("child_process");
-var import_node_fs8 = require("fs");
-var import_promises5 = require("fs/promises");
+var import_node_fs9 = require("fs");
+var import_promises6 = require("fs/promises");
 var import_node_module = require("module");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // ../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
 var import_node_process8 = __toESM(require("process"), 1);
@@ -1037,19 +1037,19 @@ var baseOpen = async (options) => {
   }
   const subprocess = import_node_child_process7.default.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve(subprocess);
+        resolve2(subprocess);
       });
     });
   }
   if (isFallbackAttempt) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       subprocess.once("error", reject);
       subprocess.once("spawn", () => {
         subprocess.once("close", (exitCode) => {
@@ -1059,17 +1059,17 @@ var baseOpen = async (options) => {
             return;
           }
           subprocess.unref();
-          resolve(subprocess);
+          resolve2(subprocess);
         });
       });
     });
   }
   subprocess.unref();
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     subprocess.once("error", reject);
     subprocess.once("spawn", () => {
       subprocess.off("error", reject);
-      resolve(subprocess);
+      resolve2(subprocess);
     });
   });
 };
@@ -1515,12 +1515,12 @@ var LOGIN_TIMEOUT = 3e5;
 async function findAvailablePort(startPort = 8765) {
   for (let port = startPort; port < startPort + 100; port++) {
     try {
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         const server = (0, import_node_http.createServer)();
         server.once("error", reject);
         server.once("listening", () => {
           server.close();
-          resolve();
+          resolve2();
         });
         server.listen(port);
       });
@@ -1532,7 +1532,7 @@ async function findAvailablePort(startPort = 8765) {
   throw new Error("No available ports found");
 }
 async function startCallbackServer(port, expectedState) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let tokenResolver = null;
     const tokenPromise = new Promise((res) => {
       tokenResolver = res;
@@ -1774,7 +1774,7 @@ async function startCallbackServer(port, expectedState) {
       }
     );
     server.listen(port, () => {
-      resolve({ server, token: tokenPromise });
+      resolve2({ server, token: tokenPromise });
     });
     server.on("error", reject);
   });
@@ -3272,14 +3272,14 @@ async function prompt(question, defaultValue = "n") {
     /(\(y\/n\):)/,
     `(${defaultIndicator}):`
   );
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(questionWithDefault, (answer) => {
       rl.close();
       const trimmedAnswer = answer.trim().toLowerCase();
       if (trimmedAnswer === "") {
-        resolve(defaultValue === "y");
+        resolve2(defaultValue === "y");
       } else {
-        resolve(trimmedAnswer === "y" || trimmedAnswer === "yes");
+        resolve2(trimmedAnswer === "y" || trimmedAnswer === "yes");
       }
     });
   });
@@ -3356,7 +3356,7 @@ async function displayDeploymentProgress(api, deployment) {
   let lastDisplayedLogLength = 0;
   while (checkCount < maxChecks) {
     const currentDelay = delay;
-    await new Promise((resolve) => setTimeout(resolve, currentDelay));
+    await new Promise((resolve2) => setTimeout(resolve2, currentDelay));
     const finalDeployment = await api.getDeployment(deployment.id);
     if (finalDeployment.buildLogs && finalDeployment.buildLogs.length > lastDisplayedLogLength) {
       const newLogs = finalDeployment.buildLogs.substring(
@@ -3980,11 +3980,11 @@ async function prompt2(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(question, (answer) => {
       rl.close();
       const trimmedAnswer = answer.trim().toLowerCase();
-      resolve(trimmedAnswer === "y" || trimmedAnswer === "yes");
+      resolve2(trimmedAnswer === "y" || trimmedAnswer === "yes");
     });
   });
 }
@@ -4499,10 +4499,126 @@ function createDeploymentsCommand() {
   return deploymentsCommand;
 }
 
+// src/commands/skills.ts
+var import_commander3 = require("commander");
+var import_node_fs8 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path6 = require("path");
+var import_node_stream = require("stream");
+var import_promises5 = require("stream/promises");
+var import_tar = require("tar");
+var REPO_OWNER = "mcp-use";
+var REPO_NAME = "mcp-use";
+var REPO_BRANCH = "main";
+var TELEMETRY_URL = "https://add-skill.vercel.sh/t";
+var SOURCE_REPO = `${REPO_OWNER}/${REPO_NAME}`;
+var AGENT_PRESET_FOLDERS = {
+  cursor: ".cursor",
+  "claude-code": ".claude",
+  codex: ".agent"
+};
+var ALL_PRESETS = ["cursor", "claude-code", "codex"];
+function sendInstallTelemetryEvent(agents, skills) {
+  const telemetryData = {
+    event: "install",
+    source: SOURCE_REPO,
+    skills,
+    agents,
+    sourceType: "github"
+  };
+  try {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(telemetryData)) {
+      if (value !== void 0 && value !== null) {
+        params.set(key, String(value));
+      }
+    }
+    fetch(`${TELEMETRY_URL}?${params.toString()}`).catch(() => {
+    });
+  } catch {
+  }
+}
+async function addSkillsToProject(projectPath) {
+  const tarballUrl = `https://codeload.github.com/${REPO_OWNER}/${REPO_NAME}/tar.gz/${REPO_BRANCH}`;
+  const tempDir = (0, import_node_fs8.mkdtempSync)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), "mcp-use-skills-"));
+  try {
+    const response = await fetch(tarballUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to download tarball: ${response.statusText}`);
+    }
+    await (0, import_promises5.pipeline)(
+      import_node_stream.Readable.fromWeb(response.body),
+      (0, import_tar.extract)({
+        cwd: tempDir,
+        filter: (path6) => path6.includes("/skills/"),
+        strip: 1
+      })
+    );
+    const skillsPath = (0, import_node_path6.join)(tempDir, "skills");
+    if (!(0, import_node_fs8.existsSync)(skillsPath)) {
+      throw new Error("Skills folder not found in repository");
+    }
+    for (const preset of ALL_PRESETS) {
+      const folderName = AGENT_PRESET_FOLDERS[preset];
+      const outputPath = (0, import_node_path6.join)(projectPath, folderName, "skills");
+      (0, import_node_fs8.cpSync)(skillsPath, outputPath, { recursive: true });
+    }
+    const skillNames = (0, import_node_fs8.readdirSync)(skillsPath, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    sendInstallTelemetryEvent(ALL_PRESETS.join(","), skillNames.join(","));
+  } finally {
+    (0, import_node_fs8.rmSync)(tempDir, { recursive: true, force: true });
+  }
+}
+function createSkillsCommand() {
+  const skills = new import_commander3.Command("skills").description(
+    "Manage mcp-use AI agent skills"
+  );
+  const installAction = async (options) => {
+    const projectPath = (0, import_node_path6.resolve)(options.path);
+    if (!(0, import_node_fs8.existsSync)(projectPath)) {
+      console.error(source_default.red(`Directory not found: ${projectPath}`));
+      process.exit(1);
+    }
+    console.log(source_default.cyan("\u{1F4DA} Installing mcp-use skills..."));
+    console.log(
+      source_default.gray(
+        "   Downloading from github.com/mcp-use/mcp-use \u2192 .cursor/skills, .claude/skills, .agent/skills"
+      )
+    );
+    try {
+      await addSkillsToProject(projectPath);
+      console.log(source_default.green("\u2705 Skills installed successfully!"));
+    } catch (error) {
+      console.error(source_default.red("\u274C Failed to install skills."));
+      console.error(
+        source_default.yellow(
+          `   Error: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+      console.error(
+        source_default.yellow(
+          "   You can also install manually: npx skills add mcp-use/mcp-use"
+        )
+      );
+      process.exit(1);
+    }
+  };
+  const pathOption = [
+    "-p, --path <path>",
+    "Path to project directory",
+    process.cwd()
+  ];
+  skills.command("add").description(
+    "Install mcp-use skills for AI agents (Cursor, Claude Code, Codex)"
+  ).option(...pathOption).action(installAction);
+  skills.command("install").description("Install mcp-use skills for AI agents (alias for 'add')").option(...pathOption).action(installAction);
+  return skills;
+}
+
 // src/index.ts
-var program = new import_commander3.Command();
-var packageContent = (0, import_node_fs8.readFileSync)(
-  import_node_path6.default.join(__dirname, "../package.json"),
+var program = new import_commander4.Command();
+var packageContent = (0, import_node_fs9.readFileSync)(
+  import_node_path7.default.join(__dirname, "../package.json"),
   "utf-8"
 );
 var packageJson = JSON.parse(packageContent);
@@ -4533,16 +4649,16 @@ function displayPackageVersions(projectPath) {
       if (projectPath) {
         try {
           const projectRequire = (0, import_node_module.createRequire)(
-            import_node_path6.default.join(projectPath, "package.json")
+            import_node_path7.default.join(projectPath, "package.json")
           );
           pkgPath = projectRequire.resolve(`${pkg.name}/package.json`);
         } catch (resolveError) {
-          pkgPath = import_node_path6.default.join(__dirname, pkg.relativePath);
+          pkgPath = import_node_path7.default.join(__dirname, pkg.relativePath);
         }
       } else {
-        pkgPath = import_node_path6.default.join(__dirname, pkg.relativePath);
+        pkgPath = import_node_path7.default.join(__dirname, pkg.relativePath);
       }
-      const pkgContent = (0, import_node_fs8.readFileSync)(pkgPath, "utf-8");
+      const pkgContent = (0, import_node_fs9.readFileSync)(pkgPath, "utf-8");
       const pkgJson = JSON.parse(pkgContent);
       const version = pkgJson.version || "unknown";
       if (pkg.highlight) {
@@ -4589,7 +4705,7 @@ async function waitForServer(port, host = "localhost", maxAttempts = 30) {
     } finally {
       controller.abort();
     }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
   }
   return false;
 }
@@ -4611,11 +4727,11 @@ function runCommand(command, args, cwd, env2, filterStderr = false) {
       }
     });
   }
-  const promise = new Promise((resolve, reject) => {
+  const promise = new Promise((resolve2, reject) => {
     proc.on("error", reject);
     proc.on("exit", (code) => {
       if (code === 0 || code === 130 || code === 143) {
-        resolve();
+        resolve2();
       } else {
         reject(new Error(`Command failed with exit code ${code}`));
       }
@@ -4624,7 +4740,7 @@ function runCommand(command, args, cwd, env2, filterStderr = false) {
   return { promise, process: proc };
 }
 async function startTunnel(port, subdomain) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     console.log(source_default.gray(`Starting tunnel for port ${port}...`));
     const tunnelArgs = ["--yes", "@mcp-use/tunnel", String(port)];
     if (subdomain) {
@@ -4659,7 +4775,7 @@ async function startTunnel(port, subdomain) {
         resolved = true;
         clearTimeout(setupTimeout);
         console.log(source_default.green.bold(`\u2713 Tunnel established: ${url}/mcp`));
-        resolve({ url, subdomain: extractedSubdomain, process: proc });
+        resolve2({ url, subdomain: extractedSubdomain, process: proc });
       }
     });
     proc.stderr?.on("data", (data) => {
@@ -4695,7 +4811,7 @@ async function findServerFile(projectPath) {
   const candidates = ["index.ts", "src/index.ts", "server.ts", "src/server.ts"];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises5.access)(import_node_path6.default.join(projectPath, candidate));
+      await (0, import_promises6.access)(import_node_path7.default.join(projectPath, candidate));
       return candidate;
     } catch {
       continue;
@@ -4707,10 +4823,10 @@ async function buildWidgets(projectPath, options = {}) {
   const { inline = true } = options;
   const { promises: fs10 } = await import("fs");
   const { build } = await import("vite");
-  const resourcesDir = import_node_path6.default.join(projectPath, "resources");
+  const resourcesDir = import_node_path7.default.join(projectPath, "resources");
   const mcpUrl = process.env.MCP_URL;
   try {
-    await (0, import_promises5.access)(resourcesDir);
+    await (0, import_promises6.access)(resourcesDir);
   } catch {
     console.log(
       source_default.gray("No resources/ directory found - skipping widget build")
@@ -4727,10 +4843,10 @@ async function buildWidgets(projectPath, options = {}) {
       if (dirent.isFile() && (dirent.name.endsWith(".tsx") || dirent.name.endsWith(".ts"))) {
         entries.push({
           name: dirent.name.replace(/\.tsx?$/, ""),
-          path: import_node_path6.default.join(resourcesDir, dirent.name)
+          path: import_node_path7.default.join(resourcesDir, dirent.name)
         });
       } else if (dirent.isDirectory()) {
-        const widgetPath = import_node_path6.default.join(resourcesDir, dirent.name, "widget.tsx");
+        const widgetPath = import_node_path7.default.join(resourcesDir, dirent.name, "widget.tsx");
         try {
           await fs10.access(widgetPath);
           entries.push({
@@ -4756,7 +4872,7 @@ async function buildWidgets(projectPath, options = {}) {
   );
   const react = (await import("@vitejs/plugin-react")).default;
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const packageJsonPath = import_node_path6.default.join(projectPath, "package.json");
+  const packageJsonPath = import_node_path7.default.join(projectPath, "package.json");
   let favicon = "";
   try {
     const pkgContent = await fs10.readFile(packageJsonPath, "utf-8");
@@ -4768,18 +4884,18 @@ async function buildWidgets(projectPath, options = {}) {
     const widgetName = entry.name;
     const entryPath = entry.path.replace(/\\/g, "/");
     console.log(source_default.gray(`  - Building ${widgetName}...`));
-    const tempDir = import_node_path6.default.join(projectPath, ".mcp-use", widgetName);
+    const tempDir = import_node_path7.default.join(projectPath, ".mcp-use", widgetName);
     await fs10.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = import_node_path6.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
-    const mcpUsePath = import_node_path6.default.join(projectPath, "node_modules", "mcp-use");
-    const relativeMcpUsePath = import_node_path6.default.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
+    const relativeResourcesPath = import_node_path7.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
+    const mcpUsePath = import_node_path7.default.join(projectPath, "node_modules", "mcp-use");
+    const relativeMcpUsePath = import_node_path7.default.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
     const cssContent = `@import "tailwindcss";
 
 /* Configure Tailwind to scan the resources directory and mcp-use package */
 @source "${relativeResourcesPath}";
 @source "${relativeMcpUsePath}/**/*.{ts,tsx,js,jsx}";
 `;
-    await fs10.writeFile(import_node_path6.default.join(tempDir, "styles.css"), cssContent, "utf8");
+    await fs10.writeFile(import_node_path7.default.join(tempDir, "styles.css"), cssContent, "utf8");
     const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -4804,9 +4920,9 @@ if (container && Component) {
     <script type="module" src="/entry.tsx"></script>
   </body>
 </html>`;
-    await fs10.writeFile(import_node_path6.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs10.writeFile(import_node_path6.default.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = import_node_path6.default.join(
+    await fs10.writeFile(import_node_path7.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
+    await fs10.writeFile(import_node_path7.default.join(tempDir, "index.html"), htmlContent, "utf8");
+    const outDir = import_node_path7.default.join(
       projectPath,
       "dist",
       "resources",
@@ -4816,7 +4932,7 @@ if (container && Component) {
     const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
     let widgetMetadata = {};
     try {
-      const metadataTempDir = import_node_path6.default.join(
+      const metadataTempDir = import_node_path7.default.join(
         projectPath,
         ".mcp-use",
         `${widgetName}-metadata`
@@ -4851,7 +4967,7 @@ export default PostHog;
       };
       const metadataServer = await createServer2({
         root: metadataTempDir,
-        cacheDir: import_node_path6.default.join(metadataTempDir, ".vite-cache"),
+        cacheDir: import_node_path7.default.join(metadataTempDir, ".vite-cache"),
         plugins: [nodeStubsPlugin, tailwindcss(), react()],
         resolve: {
           alias: {
@@ -4928,7 +5044,7 @@ export default PostHog;
             inputs: inputsValue
           };
         }
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
       } catch (error) {
         console.warn(
           source_default.yellow(`    \u26A0 Could not extract metadata for ${widgetName}`)
@@ -5081,7 +5197,7 @@ export default {
             // Inline all assets under 100MB (effectively all)
           } : {},
           rollupOptions: {
-            input: import_node_path6.default.join(tempDir, "index.html"),
+            input: import_node_path7.default.join(tempDir, "index.html"),
             external: (id) => {
               return false;
             }
@@ -5089,11 +5205,11 @@ export default {
         }
       });
       try {
-        const assetsDir = import_node_path6.default.join(outDir, "assets");
+        const assetsDir = import_node_path7.default.join(outDir, "assets");
         const assetFiles = await fs10.readdir(assetsDir);
         const jsFiles = assetFiles.filter((f) => f.endsWith(".js"));
         for (const jsFile of jsFiles) {
-          const jsPath = import_node_path6.default.join(assetsDir, jsFile);
+          const jsPath = import_node_path7.default.join(assetsDir, jsFile);
           let content = await fs10.readFile(jsPath, "utf8");
           const zodConfigPatterns = [
             // Non-minified: export const globalConfig = {}
@@ -5125,7 +5241,7 @@ export default {
       const mcpServerUrl = process.env.MCP_SERVER_URL;
       if (mcpServerUrl) {
         try {
-          const htmlPath = import_node_path6.default.join(outDir, "index.html");
+          const htmlPath = import_node_path7.default.join(outDir, "index.html");
           let html = await fs10.readFile(htmlPath, "utf8");
           const injectionScript = `<script>window.__getFile = (filename) => { return "${mcpUrl}/${widgetName}/"+filename }; window.__mcpPublicUrl = "${mcpServerUrl}/mcp-use/public"; window.__mcpPublicAssetsUrl = "${mcpUrl}/public";</script>`;
           if (!html.includes("window.__mcpPublicUrl")) {
@@ -5180,7 +5296,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
   "Inline all JS/CSS into HTML (required for VS Code MCP Apps)"
 ).option("--no-inline", "Keep JS/CSS as separate files (default)").action(async (options) => {
   try {
-    const projectPath = import_node_path6.default.resolve(options.path);
+    const projectPath = import_node_path7.default.resolve(options.path);
     const { promises: fs10 } = await import("fs");
     displayPackageVersions(projectPath);
     const builtWidgets = await buildWidgets(projectPath, {
@@ -5196,7 +5312,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
     console.log(source_default.green("\u2713 TypeScript build complete!"));
     let entryPoint;
     if (sourceServerFile) {
-      const baseName = import_node_path6.default.basename(sourceServerFile, ".ts") + ".js";
+      const baseName = import_node_path7.default.basename(sourceServerFile, ".ts") + ".js";
       const possibleOutputs = [
         `dist/${baseName}`,
         // rootDir set to project root or src
@@ -5207,7 +5323,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       ];
       for (const candidate of possibleOutputs) {
         try {
-          await (0, import_promises5.access)(import_node_path6.default.join(projectPath, candidate));
+          await (0, import_promises6.access)(import_node_path7.default.join(projectPath, candidate));
           entryPoint = candidate;
           break;
         } catch {
@@ -5215,17 +5331,17 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
         }
       }
     }
-    const publicDir = import_node_path6.default.join(projectPath, "public");
+    const publicDir = import_node_path7.default.join(projectPath, "public");
     try {
       await fs10.access(publicDir);
       console.log(source_default.gray("Copying public assets..."));
-      await fs10.cp(publicDir, import_node_path6.default.join(projectPath, "dist", "public"), {
+      await fs10.cp(publicDir, import_node_path7.default.join(projectPath, "dist", "public"), {
         recursive: true
       });
       console.log(source_default.green("\u2713 Public assets copied"));
     } catch {
     }
-    const manifestPath = import_node_path6.default.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = import_node_path7.default.join(projectPath, "dist", "mcp-use.json");
     let existingManifest = {};
     try {
       const existingContent = await fs10.readFile(manifestPath, "utf-8");
@@ -5250,7 +5366,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       // Server entry point for `mcp-use start`
       widgets: widgetsData
     };
-    await fs10.mkdir(import_node_path6.default.dirname(manifestPath), { recursive: true });
+    await fs10.mkdir(import_node_path7.default.dirname(manifestPath), { recursive: true });
     await fs10.writeFile(
       manifestPath,
       JSON.stringify(manifest, null, 2),
@@ -5276,7 +5392,7 @@ program.command("dev").description("Run development server with auto-reload and
   "0.0.0.0"
 ).option("--no-open", "Do not auto-open inspector").option("--no-hmr", "Disable hot module reloading (use tsx watch instead)").action(async (options) => {
   try {
-    const projectPath = import_node_path6.default.resolve(options.path);
+    const projectPath = import_node_path7.default.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
     const useHmr = options.hmr !== false;
@@ -5310,10 +5426,10 @@ program.command("dev").description("Run development server with auto-reload and
       let args;
       try {
         const projectRequire = createRequire3(
-          import_node_path6.default.join(projectPath, "package.json")
+          import_node_path7.default.join(projectPath, "package.json")
         );
         const tsxPkgPath = projectRequire.resolve("tsx/package.json");
-        const tsxPkg = JSON.parse(await (0, import_promises5.readFile)(tsxPkgPath, "utf-8"));
+        const tsxPkg = JSON.parse(await (0, import_promises6.readFile)(tsxPkgPath, "utf-8"));
         let binPath;
         if (typeof tsxPkg.bin === "string") {
           binPath = tsxPkg.bin;
@@ -5322,7 +5438,7 @@ program.command("dev").description("Run development server with auto-reload and
         } else {
           throw new Error("No bin field found in tsx package.json");
         }
-        const tsxBin = import_node_path6.default.resolve(import_node_path6.default.dirname(tsxPkgPath), binPath);
+        const tsxBin = import_node_path7.default.resolve(import_node_path7.default.dirname(tsxPkgPath), binPath);
         cmd = "node";
         args = [tsxBin, "watch", serverFile];
       } catch (error) {
@@ -5382,7 +5498,7 @@ program.command("dev").description("Run development server with auto-reload and
     let tsImport = null;
     try {
       const projectRequire = createRequire2(
-        import_node_path6.default.join(projectPath, "package.json")
+        import_node_path7.default.join(projectPath, "package.json")
       );
       const tsxApiPath = projectRequire.resolve("tsx/esm/api");
       const tsxApi = await import(pathToFileURL(tsxApiPath).href);
@@ -5394,7 +5510,7 @@ program.command("dev").description("Run development server with auto-reload and
         )
       );
     }
-    const serverFilePath = import_node_path6.default.join(projectPath, serverFile);
+    const serverFilePath = import_node_path7.default.join(projectPath, serverFile);
     const serverFileUrl = pathToFileURL(serverFilePath).href;
     globalThis.__mcpUseHmrMode = true;
     const importServerModule = async () => {
@@ -5628,7 +5744,7 @@ program.command("dev").description("Run development server with auto-reload and
 });
 program.command("start").description("Start production server").option("-p, --path <path>", "Path to project directory", process.cwd()).option("--port <port>", "Server port", "3000").option("--tunnel", "Expose server through a tunnel").action(async (options) => {
   try {
-    const projectPath = import_node_path6.default.resolve(options.path);
+    const projectPath = import_node_path7.default.resolve(options.path);
     const portFlagProvided = process.argv.includes("--port") || process.argv.includes("-p") || process.argv.some((arg) => arg.startsWith("--port=")) || process.argv.some((arg) => arg.startsWith("-p="));
     const port = portFlagProvided ? parseInt(options.port, 10) : parseInt(process.env.PORT || options.port || "3000", 10);
     console.log(
@@ -5640,10 +5756,10 @@ program.command("start").description("Start production server").option("-p, --pa
     let tunnelSubdomain = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath2 = import_node_path6.default.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath2 = import_node_path7.default.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
-          const manifestContent = await (0, import_promises5.readFile)(manifestPath2, "utf-8");
+          const manifestContent = await (0, import_promises6.readFile)(manifestPath2, "utf-8");
           const manifest = JSON.parse(manifestContent);
           existingSubdomain = manifest.tunnel?.subdomain;
           if (existingSubdomain) {
@@ -5666,7 +5782,7 @@ program.command("start").description("Start production server").option("-p, --pa
         try {
           let manifest = {};
           try {
-            const manifestContent = await (0, import_promises5.readFile)(manifestPath2, "utf-8");
+            const manifestContent = await (0, import_promises6.readFile)(manifestPath2, "utf-8");
             manifest = JSON.parse(manifestContent);
           } catch {
           }
@@ -5674,8 +5790,8 @@ program.command("start").description("Start production server").option("-p, --pa
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = subdomain;
-          await (0, import_promises5.mkdir)(import_node_path6.default.dirname(manifestPath2), { recursive: true });
-          await (0, import_promises5.writeFile)(
+          await (0, import_promises6.mkdir)(import_node_path7.default.dirname(manifestPath2), { recursive: true });
+          await (0, import_promises6.writeFile)(
             manifestPath2,
             JSON.stringify(manifest, null, 2),
             "utf-8"
@@ -5693,12 +5809,12 @@ program.command("start").description("Start production server").option("-p, --pa
       }
     }
     let serverFile;
-    const manifestPath = import_node_path6.default.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = import_node_path7.default.join(projectPath, "dist", "mcp-use.json");
     try {
-      const manifestContent = await (0, import_promises5.readFile)(manifestPath, "utf-8");
+      const manifestContent = await (0, import_promises6.readFile)(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       if (manifest.entryPoint) {
-        await (0, import_promises5.access)(import_node_path6.default.join(projectPath, manifest.entryPoint));
+        await (0, import_promises6.access)(import_node_path7.default.join(projectPath, manifest.entryPoint));
         serverFile = manifest.entryPoint;
       }
     } catch {
@@ -5712,7 +5828,7 @@ program.command("start").description("Start production server").option("-p, --pa
       ];
       for (const candidate of serverCandidates) {
         try {
-          await (0, import_promises5.access)(import_node_path6.default.join(projectPath, candidate));
+          await (0, import_promises6.access)(import_node_path7.default.join(projectPath, candidate));
           serverFile = candidate;
           break;
         } catch {
@@ -5845,13 +5961,14 @@ program.command("deploy").description("Deploy MCP server from GitHub to Manufact
 });
 program.addCommand(createClientCommand());
 program.addCommand(createDeploymentsCommand());
+program.addCommand(createSkillsCommand());
 program.command("generate-types").description(
   "Generate TypeScript type definitions for tools (writes .mcp-use/tool-registry.d.ts)"
 ).option("-p, --path <path>", "Path to project directory", process.cwd()).option("--server <file>", "Server entry file", "index.ts").action(async (options) => {
-  const projectPath = import_node_path6.default.resolve(options.path);
-  const serverFile = import_node_path6.default.join(projectPath, options.server);
+  const projectPath = import_node_path7.default.resolve(options.path);
+  const serverFile = import_node_path7.default.join(projectPath, options.server);
   try {
-    if (!await (0, import_promises5.access)(serverFile).then(() => true).catch(() => false)) {
+    if (!await (0, import_promises6.access)(serverFile).then(() => true).catch(() => false)) {
       console.error(source_default.red(`Server file not found: ${serverFile}`));
       process.exit(1);
     }
@@ -5860,7 +5977,7 @@ program.command("generate-types").description(
     const { tsImport } = await import("tsx/esm/api");
     await tsImport(serverFile, {
       parentURL: importMetaUrl,
-      tsconfig: import_node_path6.default.join(projectPath, "tsconfig.json")
+      tsconfig: import_node_path7.default.join(projectPath, "tsconfig.json")
     });
     const server = globalThis.__mcpUseLastServer;
     if (!server) {
@@ -5871,8 +5988,8 @@ program.command("generate-types").description(
       );
       process.exit(1);
     }
-    const mcpUsePath = import_node_path6.default.join(projectPath, "node_modules", "mcp-use");
-    const { generateToolRegistryTypes } = await import(import_node_path6.default.join(mcpUsePath, "dist", "src", "server", "index.js")).then((mod) => mod);
+    const mcpUsePath = import_node_path7.default.join(projectPath, "node_modules", "mcp-use");
+    const { generateToolRegistryTypes } = await import(import_node_path7.default.join(mcpUsePath, "dist", "src", "server", "index.js")).then((mod) => mod);
     if (!generateToolRegistryTypes) {
       throw new Error(
         "generateToolRegistryTypes not found in mcp-use package"