skills 1.5.26 → 1.7.0

package/README.md

@@ -6,7 +6,13 @@ The CLI for the open agent skills ecosystem.
 Supports **OpenCode**, **Claude Code**, **Codex**, **Cursor**, and [75 more](#supported-agents).
 <!-- agent-list:end -->
 
-[![skills.sh](https://skills.sh/b/vercel-labs/skills)](https://skills.sh/vercel-labs/skills)
+<p>
+  <a href="https://vercel.com/labs#labs-products"><img alt="Vercel Labs Product" src="https://img.shields.io/badge/LABS-PRODUCT-0a0a0a.svg?style=for-the-badge&amp;logo=Vercel&amp;labelColor=000000" height="28"></a>
+  <a href="https://www.npmjs.com/package/skills"><img alt="npm version: skills" src="https://img.shields.io/npm/v/skills.svg?style=for-the-badge&amp;labelColor=000000" height="28"></a>
+  <a href="https://github.com/vercel-labs/skills/blob/main/LICENSE"><img alt="License: MIT" src="https://img.shields.io/github/license/vercel-labs/skills.svg?style=for-the-badge&amp;labelColor=000000" height="28"></a>
+  <a href="https://www.npmjs.com/package/skills"><img alt="npm downloads per month: skills" src="https://img.shields.io/npm/dm/skills.svg?style=for-the-badge&amp;labelColor=000000&amp;label=npm%20downloads" height="28"></a>
+  <a href="https://skills.sh/vercel-labs/skills"><img alt="skills.sh" src="https://skills.sh/b/vercel-labs/skills?style=for-the-badge" height="28"></a>
+</p>
 
 ## Install a Skill
 
@@ -40,6 +46,10 @@ npx skills add https://github.com/vercel-labs/agent-skills/tree/main/skills/web-
 # GitLab URL
 npx skills add https://gitlab.com/org/repo
 
+# Azure Repos (Azure DevOps Services or Server)
+npx skills add https://dev.azure.com/org/project/_git/repo
+npx skills add https://dev.azure.com/org/project/_git/repo?path=/skills/web-design&version=GBmain
+
 # Any git URL
 npx skills add git@github.com:vercel-labs/agent-skills.git
 
@@ -61,6 +71,7 @@ npx skills add ssh://git@git.example.com/acme/private-skills.git
 
 # HTTPS on any Git host (uses your configured Git credential helper)
 npx skills add https://git.example.com/acme/private-skills.git
+npx skills add https://dev.azure.com/org/project/_git/private-skills
 ```
 
 For GitHub HTTPS and shorthand sources, `skills` first uses normal Git credentials. If that fails and GitHub CLI is authenticated, it tries `gh repo clone`, followed by SSH. It does not execute `gh auth token` or copy the stored GitHub CLI credential into the Node.js process.

package/dist/cli.mjs

@@ -11,7 +11,7 @@ import { basename, dirname, extname, isAbsolute, join, normalize, relative, reso
 import { fileURLToPath } from "url";
 import { stripVTControlCharacters } from "node:util";
 import { createWriteStream } from "node:fs";
-import { dirname as dirname$1, join as join$1, normalize as normalize$1, resolve as resolve$1, sep as sep$1 } from "node:path";
+import { dirname as dirname$1, join as join$1, normalize as normalize$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "node:path";
 import { homedir, platform, tmpdir } from "os";
 import * as readline from "readline";
 import { Writable } from "stream";
@@ -20,13 +20,13 @@ import { execFile, spawn, spawnSync } from "child_process";
 import { access, chmod, cp, lstat, mkdir, mkdtemp, readFile, readdir, readlink, realpath, rm, stat, symlink, writeFile } from "fs/promises";
 import { parse, stringify } from "yaml";
 import { createHash } from "crypto";
-import { mkdir as mkdir$1, mkdtemp as mkdtemp$1, readFile as readFile$1, rm as rm$1, stat as stat$1, writeFile as writeFile$1 } from "node:fs/promises";
+import { cp as cp$1, mkdir as mkdir$1, mkdtemp as mkdtemp$1, readFile as readFile$1, rm as rm$1, stat as stat$1, writeFile as writeFile$1 } from "node:fs/promises";
 import { createHash as createHash$1 } from "node:crypto";
 import { crc32, gunzipSync, inflateRawSync } from "node:zlib";
 import { tmpdir as tmpdir$1 } from "node:os";
 import { pipeline } from "node:stream/promises";
 import * as tar from "tar";
-import { execFile as execFile$1 } from "node:child_process";
+import { execFile as execFile$1, spawn as spawn$1 } from "node:child_process";
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 const DEFAULT_GITHUB_HOST = "github.com";
 function getGitHubHost() {
@@ -91,6 +91,46 @@ function sanitizeSubpath(subpath) {
 	for (const segment of segments) if (segment === "..") throw new Error(`Unsafe subpath: "${subpath}" contains path traversal segments. Subpaths must not contain ".." components.`);
 	return subpath;
 }
+function azureReposVersionToRef(version) {
+	if (!version) return;
+	return /^(?:GB|GT)(.+)$/i.exec(version)?.[1] || void 0;
+}
+function parseAzureReposSource(input, fragmentRef, fragmentSkillFilter) {
+	if (!input.startsWith("http://") && !input.startsWith("https://")) return null;
+	let parsed;
+	try {
+		parsed = new URL(input);
+	} catch {
+		return null;
+	}
+	const segments = parsed.pathname.split("/").filter(Boolean);
+	const gitIndex = segments.indexOf("_git");
+	if (gitIndex < 0 || gitIndex === segments.length - 1) return null;
+	const repo = segments[gitIndex + 1].replace(/\.git$/, "");
+	if (!repo) return null;
+	const clonePath = "/" + [
+		...segments.slice(0, gitIndex),
+		"_git",
+		repo
+	].map((segment) => {
+		try {
+			return encodeURIComponent(decodeURIComponent(segment));
+		} catch {
+			return encodeURIComponent(segment);
+		}
+	}).join("/");
+	const cloneUrl = `${parsed.protocol}//${parsed.host}${clonePath}`;
+	const ref = azureReposVersionToRef(parsed.searchParams.get("version")) || fragmentRef;
+	const pathParam = parsed.searchParams.get("path");
+	const subpath = pathParam ? sanitizeSubpath(pathParam.replace(/^\/+/, "")) : void 0;
+	return {
+		type: "git",
+		url: cloneUrl,
+		...ref ? { ref } : {},
+		...subpath ? { subpath } : {},
+		...fragmentSkillFilter ? { skillFilter: fragmentSkillFilter } : {}
+	};
+}
 function isLocalPath(input) {
 	return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
 }
@@ -113,6 +153,9 @@ function looksLikeGitSource(input) {
 		const pathname = parsed.pathname;
 		if (isGitHubHost(parsed.host)) return /^\/[^/]+\/[^/]+(?:\.git)?(?:\/tree\/[^/]+(?:\/.*)?)?\/?$/.test(pathname);
 		if (parsed.hostname === "gitlab.com") return /^\/.+?\/[^/]+(?:\.git)?(?:\/-\/tree\/[^/]+(?:\/.*)?)?\/?$/.test(pathname);
+		const azureSegments = pathname.split("/").filter(Boolean);
+		const azureGitIndex = azureSegments.indexOf("_git");
+		if (azureGitIndex >= 0 && azureGitIndex < azureSegments.length - 1) return true;
 	} catch {}
 	if (/^https?:\/\/.+\.git(?:$|[/?])/i.test(input)) return true;
 	return !input.includes(":") && !input.startsWith(".") && !input.startsWith("/") && /^([^/]+)\/([^/]+)(?:\/(.+)|@(.+))?$/.test(input);
@@ -245,6 +288,8 @@ function parseSource(input) {
 			...fragmentRef ? { ref: fragmentRef } : {}
 		};
 	}
+	const azureRepos = parseAzureReposSource(input, fragmentRef, fragmentSkillFilter);
+	if (azureRepos) return azureRepos;
 	const githubHost = getGitHubHost();
 	const shorthandSourceType = githubHost === "github.com" ? "github" : "git";
 	const atSkillMatch = input.match(/^([^/]+)\/([^/@]+)@(.+)$/);
@@ -1183,7 +1228,7 @@ function normalizeSkillName$1(name) {
 function normalizeRelativePath(path) {
 	return path.split(sep).join("/").replace(/\/+/g, "/");
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function shouldInstallInternalSkills() {
@@ -1226,7 +1271,7 @@ async function parseSkillMd(skillMdPath, options) {
 		warnSkippedSkill(skillMdPath, `frontmatter "name" and "description" must be strings (got ${typeof data.name} and ${typeof data.description})`);
 		return null;
 	}
-	const metadata = isRecord(data.metadata) ? data.metadata : void 0;
+	const metadata = isRecord$1(data.metadata) ? data.metadata : void 0;
 	if (metadata?.internal === true && !shouldInstallInternalSkills() && !options?.includeInternal) return null;
 	return {
 		name: sanitizeMetadata(data.name),
@@ -3515,17 +3560,20 @@ const DEFAULT_DOWNLOAD_MAX_BYTES = 10 * 1024 * 1024;
 const DEFAULT_EXTRACT_MAX_BYTES = 25 * 1024 * 1024;
 const DEFAULT_EXTRACT_MAX_FILES = 1e3;
 const FETCH_TIMEOUT_MS = 3e4;
+function positiveIntegerOr(value, fallback) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
 function getPositiveIntegerEnv(name, fallback) {
 	const raw = process.env[name];
 	if (!raw) return fallback;
 	const parsed = Number.parseInt(raw, 10);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
-function getDownloadLimits() {
+function getDownloadLimits(options) {
 	return {
-		downloadMaxBytes: getPositiveIntegerEnv("SKILLS_DOWNLOAD_MAX_BYTES", DEFAULT_DOWNLOAD_MAX_BYTES),
-		extractMaxBytes: getPositiveIntegerEnv("SKILLS_EXTRACT_MAX_BYTES", DEFAULT_EXTRACT_MAX_BYTES),
-		extractMaxFiles: getPositiveIntegerEnv("SKILLS_EXTRACT_MAX_FILES", DEFAULT_EXTRACT_MAX_FILES)
+		downloadMaxBytes: getPositiveIntegerEnv("SKILLS_DOWNLOAD_MAX_BYTES", positiveIntegerOr(options.downloadMaxBytes, DEFAULT_DOWNLOAD_MAX_BYTES)),
+		extractMaxBytes: getPositiveIntegerEnv("SKILLS_EXTRACT_MAX_BYTES", positiveIntegerOr(options.extractMaxBytes, DEFAULT_EXTRACT_MAX_BYTES)),
+		extractMaxFiles: getPositiveIntegerEnv("SKILLS_EXTRACT_MAX_FILES", positiveIntegerOr(options.extractMaxFiles, DEFAULT_EXTRACT_MAX_FILES))
 	};
 }
 function isPathSafe$1(basePath, targetPath) {
@@ -3659,8 +3707,8 @@ async function getSingleTopLevelDirectory(dir) {
 	if (visibleEntries.length !== 1 || !visibleEntries[0].isDirectory()) return null;
 	return join$1(dir, visibleEntries[0].name);
 }
-async function downloadSource(url) {
-	const limits = getDownloadLimits();
+async function downloadSource(url, options = {}) {
+	const limits = getDownloadLimits(options);
 	const tempDir = await mkdtemp$1(join$1(tmpdir$1(), "skills-download-"));
 	const downloadedFile = join$1(tempDir, "source.download");
 	const extractDir = join$1(tempDir, "extract");
@@ -4124,7 +4172,348 @@ async function tryBlobInstall(ownerRepo, options = {}) {
 		tree
 	};
 }
-var version$1 = "1.5.26";
+var version$1 = "1.7.0";
+const NOTION_API_VERSION = "2026-03-11";
+const NTN_TIMEOUT_MS = 3e4;
+const NTN_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const NOTION_DOWNLOAD_MAX_BYTES = 50 * 1024 * 1024;
+const NOTION_EXTRACT_MAX_BYTES = 100 * 1024 * 1024;
+const NOTION_EXTRACT_MAX_FILES = 5e3;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertString(value, field) {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Notion Agent Plugins response is missing ${field}`);
+	return value;
+}
+function optionalMetadata(value, field) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value !== "string") throw new Error(`Notion Agent Plugins response has an invalid ${field}`);
+	return sanitizeMetadata(value);
+}
+function parsePack(value) {
+	if (!isRecord(value)) throw new Error("Notion Agent Plugins response contains an invalid pack");
+	if (typeof value.name !== "string") throw new Error("Notion Agent Plugins response is missing pack.name");
+	const name = sanitizeMetadata(value.name);
+	if (!name) return null;
+	return {
+		id: assertString(value.id, "pack.id"),
+		name,
+		description: optionalMetadata(value.description, "pack.description"),
+		version_id: assertString(value.version_id, "pack.version_id")
+	};
+}
+function parsePackList(value) {
+	if (!isRecord(value) || !Array.isArray(value.results)) throw new Error("Notion Agent Plugins list response is invalid");
+	if (typeof value.has_more !== "boolean") throw new Error("Notion Agent Plugins list response is missing has_more");
+	const nextCursor = value.next_cursor;
+	if (nextCursor !== null && typeof nextCursor !== "string") throw new Error("Notion Agent Plugins list response has an invalid next_cursor");
+	return {
+		results: value.results.map(parsePack).filter((pack) => pack !== null),
+		next_cursor: nextCursor,
+		has_more: value.has_more
+	};
+}
+function parseDirectory(value, label) {
+	if (!isRecord(value)) throw new Error(`Notion ${label} directory response is invalid`);
+	return {
+		id: assertString(value.id, `${label} directory id`),
+		version_id: assertString(value.version_id, `${label} directory version_id`),
+		url: assertString(value.url, `${label} directory url`)
+	};
+}
+function downloadNotionDirectory(url) {
+	return downloadSource(url, {
+		downloadMaxBytes: NOTION_DOWNLOAD_MAX_BYTES,
+		extractMaxBytes: NOTION_EXTRACT_MAX_BYTES,
+		extractMaxFiles: NOTION_EXTRACT_MAX_FILES
+	});
+}
+function debugNtn(args) {
+	if (process.env.SKILLS_DEBUG === "1") console.error(`[notion] ntn ${args.join(" ")}`);
+}
+async function runNtnApi(args) {
+	debugNtn(args);
+	return new Promise((resolve, reject) => {
+		const child = spawn$1("ntn", args, {
+			env: process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		let outputBytes = 0;
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			callback();
+		};
+		const fail = (message) => finish(() => reject(new Error(message)));
+		const append = (chunks, chunk) => {
+			outputBytes += chunk.length;
+			if (outputBytes > NTN_MAX_BUFFER_BYTES) {
+				child.kill("SIGTERM");
+				fail("ntn api output exceeded 10 MiB");
+				return;
+			}
+			chunks.push(chunk);
+		};
+		const timeout = setTimeout(() => {
+			child.kill("SIGTERM");
+			fail(`ntn api timed out after ${NTN_TIMEOUT_MS / 1e3} seconds`);
+		}, NTN_TIMEOUT_MS);
+		child.stdout.on("data", (chunk) => append(stdoutChunks, chunk));
+		child.stderr.on("data", (chunk) => append(stderrChunks, chunk));
+		child.on("error", (error) => {
+			if (error.code === "ENOENT") {
+				fail("Notion CLI (ntn) is required. Install it from:\nhttps://developers.notion.com/cli/get-started/overview\nThen run `ntn login`.");
+				return;
+			}
+			fail(`Unable to start ntn: ${stripTerminalEscapes(error.message)}`);
+		});
+		child.on("close", (code) => {
+			const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+			const stderr = stripTerminalEscapes(Buffer.concat(stderrChunks).toString("utf8")).trim();
+			if (code === 0) {
+				finish(() => resolve(stdout));
+				return;
+			}
+			fail(`ntn api failed${stderr ? `: ${stderr}` : ` with exit code ${code ?? "unknown"}`}`);
+		});
+	});
+}
+async function fetchNotionJson(args, label, runNtn = runNtnApi) {
+	const output = await runNtn([
+		"api",
+		...args,
+		"--notion-version",
+		NOTION_API_VERSION
+	]);
+	try {
+		return JSON.parse(output);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error(`ntn returned invalid JSON for ${label}`);
+		throw error;
+	}
+}
+async function fetchNotionPacks(options = {}) {
+	const runNtn = options.runNtn ?? runNtnApi;
+	const packs = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let cursor = null;
+	do {
+		const args = ["/v1/ai/plugins", "page_size==100"];
+		if (cursor) args.push(`start_cursor==${cursor}`);
+		const page = parsePackList(await fetchNotionJson(args, "the Notion packs list", runNtn));
+		packs.push(...page.results);
+		if (!page.has_more) break;
+		if (!page.next_cursor || seenCursors.has(page.next_cursor)) throw new Error("Notion Agent Plugins pagination returned an invalid cursor");
+		cursor = page.next_cursor;
+		seenCursors.add(cursor);
+	} while (cursor);
+	return packs;
+}
+async function fetchNotionPackDirectory(pack, options = {}) {
+	const directory = parseDirectory(await fetchNotionJson([`/v1/ai/plugins/${encodeURIComponent(pack.id)}`], `Notion pack ${JSON.stringify(pack.name)}`, options.runNtn), "pack");
+	if (directory.id !== pack.id || directory.version_id !== pack.version_id) throw new Error(`Notion pack ${JSON.stringify(pack.name)} changed while preparing installation`);
+	return directory;
+}
+async function fetchNotionWorkspaceName(options = {}) {
+	const runNtn = options.runNtn ?? runNtnApi;
+	try {
+		const value = JSON.parse(await runNtn([
+			"api",
+			"/v1/users/me",
+			"--notion-version",
+			NOTION_API_VERSION
+		]));
+		if (!isRecord(value) || !isRecord(value.bot)) return null;
+		const name = value.bot.workspace_name;
+		return typeof name === "string" && name.length > 0 ? sanitizeMetadata(name) : null;
+	} catch {
+		return null;
+	}
+}
+function inWorkspace(workspace) {
+	return workspace ? ` in workspace ${import_picocolors.default.cyan(workspace)}` : "";
+}
+function isNotionSource(source) {
+	return source.toLowerCase() === "notion";
+}
+const NOTION_HOSTNAME = /(^|\.)notion\.(so|com)$/;
+const NOTION_PAGE_ID = /(?:^|-)([0-9a-f]{32}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;
+function formatPageId(rawId) {
+	const hex = rawId.replace(/-/g, "");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function parseNotionSkillUrl(source) {
+	let url;
+	try {
+		url = new URL(source);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+	if (!NOTION_HOSTNAME.test(url.hostname.toLowerCase())) return null;
+	const lastSegment = url.pathname.split("/").filter(Boolean).pop();
+	if (!lastSegment) return null;
+	let decoded;
+	try {
+		decoded = decodeURIComponent(lastSegment);
+	} catch {
+		decoded = lastSegment;
+	}
+	const match = decoded.toLowerCase().match(NOTION_PAGE_ID);
+	return match ? formatPageId(match[1]) : null;
+}
+async function fetchNotionSkillDirectory(pageId, options = {}) {
+	return parseDirectory(await fetchNotionJson([`/v1/ai/skills/${encodeURIComponent(pageId)}`], `Notion skill ${pageId}`, options.runNtn), "skill");
+}
+async function prepareNotionSkillSource(pageId, options = {}) {
+	const download = options.download ?? downloadNotionDirectory;
+	const spinner$4 = spinner();
+	spinner$4.start("Fetching Notion skill with ntn…");
+	try {
+		const [directory, workspace] = await Promise.all([fetchNotionSkillDirectory(pageId, { runNtn: options.runNtn }), fetchNotionWorkspaceName({ runNtn: options.runNtn })]);
+		const downloaded = await download(directory.url);
+		spinner$4.stop(`Downloaded skill from Notion${inWorkspace(workspace)}`);
+		return {
+			rootDir: downloaded.rootDir,
+			tempDir: downloaded.tempDir
+		};
+	} catch (error) {
+		spinner$4.stop(import_picocolors.default.red("Failed to prepare Notion skill"));
+		throw error;
+	}
+}
+function normalizeSelector(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function filterPacks(packs, selectors) {
+	if (selectors.includes("*")) return packs;
+	const normalized = new Set(selectors.map(normalizeSelector));
+	return packs.filter((pack) => normalized.has(normalizeSelector(pack.name)) || normalized.has(pack.id.toLowerCase()));
+}
+function sortedPacks(packs) {
+	return [...packs].sort((a, b) => a.name.localeCompare(b.name));
+}
+function printAvailablePacks(packs) {
+	console.log();
+	log.step(import_picocolors.default.bold("Available Notion packs"));
+	for (const pack of sortedPacks(packs)) {
+		log.message(import_picocolors.default.cyan(pack.name));
+		if (pack.description) log.message(`  ${import_picocolors.default.dim(pack.description)}`);
+	}
+}
+async function prepareNotionPackSource(options = {}) {
+	const spinner$5 = spinner();
+	spinner$5.start("Fetching Notion packs with ntn…");
+	let packs;
+	let workspace = null;
+	try {
+		[packs, workspace] = await Promise.all([fetchNotionPacks({ runNtn: options.runNtn }), fetchNotionWorkspaceName({ runNtn: options.runNtn })]);
+	} catch (error) {
+		spinner$5.stop(import_picocolors.default.red("Failed to load Notion packs"));
+		throw error;
+	}
+	spinner$5.stop(`Found ${import_picocolors.default.green(packs.length)} Notion pack${packs.length === 1 ? "" : "s"}${inWorkspace(workspace)}`);
+	if (packs.length === 0) throw new Error("Notion returned no packs for the authenticated workspace");
+	if (options.list) {
+		printAvailablePacks(packs);
+		outro(import_picocolors.default.dim("Select a pack by running the command without --list."));
+		return null;
+	}
+	let selectedPacks;
+	if (options.skill && options.skill.length > 0) {
+		selectedPacks = filterPacks(packs, options.skill);
+		if (selectedPacks.length === 0) throw new Error(`No matching Notion packs found for: ${options.skill.join(", ")}`);
+	} else if (options.yes || !process.stdin.isTTY) selectedPacks = packs;
+	else {
+		const selected = await searchMultiselect({
+			message: `Select Notion packs to install ${import_picocolors.default.dim("(space to toggle)")}`,
+			items: sortedPacks(packs).map((pack) => ({
+				value: pack,
+				label: pack.name,
+				detail: pack.description || "Notion plugin pack"
+			})),
+			required: true,
+			maxVisible: 20,
+			searchable: false,
+			showDetail: true,
+			showSelectedSummary: false
+		});
+		if (typeof selected === "symbol") {
+			cancel("Selection cancelled");
+			return null;
+		}
+		selectedPacks = selected;
+	}
+	note(selectedPacks.map((pack) => import_picocolors.default.cyan(pack.name)).join("\n"), `Selected ${selectedPacks.length} Notion pack${selectedPacks.length === 1 ? "" : "s"}`);
+	const stagingDir = await mkdtemp$1(join$1(tmpdir$1(), "skills-notion-"));
+	const packsDir = join$1(stagingDir, "packs");
+	const manifestPlugins = [];
+	const download = options.download ?? downloadNotionDirectory;
+	const discover = options.discover ?? discoverSkills;
+	let skillCount = 0;
+	spinner$5.start("Preparing selected Notion packs…");
+	try {
+		await mkdir$1(packsDir, { recursive: true });
+		for (const [index, pack] of selectedPacks.entries()) {
+			let downloaded = null;
+			try {
+				downloaded = await download((await fetchNotionPackDirectory(pack, { runNtn: options.runNtn })).url);
+				const skills = await discover(downloaded.rootDir, void 0, {
+					includeInternal: true,
+					fullDepth: true
+				});
+				if (skills.length === 0) throw new Error("pack contains no valid skills");
+				const directoryName = `pack-${index + 1}-${sanitizeName(pack.name).slice(0, 100)}`;
+				const targetDir = join$1(packsDir, directoryName);
+				await cp$1(downloaded.rootDir, targetDir, {
+					recursive: true,
+					force: false,
+					errorOnExist: true
+				});
+				manifestPlugins.push({
+					name: pack.name,
+					source: `./${directoryName}`,
+					skills: skills.map((skill) => {
+						const skillPath = relative$1(downloaded.rootDir, skill.path).split(sep$1).join("/");
+						return skillPath ? `./${skillPath}` : "./.";
+					})
+				});
+				skillCount += skills.length;
+			} catch (error) {
+				const detail = error instanceof Error ? error.message : "Unknown error";
+				throw new Error(`Failed to prepare Notion pack ${JSON.stringify(pack.name)}: ${detail}`);
+			} finally {
+				if (downloaded) await cleanupTempDir(downloaded.tempDir).catch(() => {});
+			}
+		}
+		const manifestDir = join$1(stagingDir, ".claude-plugin");
+		await mkdir$1(manifestDir, { recursive: true });
+		await writeFile$1(join$1(manifestDir, "marketplace.json"), `${JSON.stringify({
+			metadata: { pluginRoot: "./packs" },
+			plugins: manifestPlugins
+		}, null, 2)}\n`, "utf8");
+		spinner$5.stop(`Prepared ${import_picocolors.default.green(selectedPacks.length)} Notion pack${selectedPacks.length === 1 ? "" : "s"} with ${import_picocolors.default.green(skillCount)} skill${skillCount === 1 ? "" : "s"}`);
+		return {
+			rootDir: stagingDir,
+			tempDir: stagingDir,
+			packCount: selectedPacks.length,
+			skillCount
+		};
+	} catch (error) {
+		spinner$5.stop(import_picocolors.default.red("Failed to prepare Notion packs"));
+		await cleanupTempDir(stagingDir).catch(() => {});
+		throw error;
+	}
+}
 const isCancelled$1 = (value) => typeof value === "symbol";
 const EVE_AGENT_LABEL = "eve agent";
 async function isSourcePrivate(source) {
@@ -4365,6 +4754,15 @@ function isSkillsShPackUrl(url) {
 		return false;
 	}
 }
+function logAutoSelectedSkills(entries) {
+	const only = entries.length === 1 ? entries[0] : null;
+	if (!only) {
+		log.info(`Installing all ${entries.length} skills`);
+		return;
+	}
+	log.info(`Skill: ${import_picocolors.default.cyan(only.label)}`);
+	if (only.description) log.message(import_picocolors.default.dim(only.description));
+}
 async function handleWellKnownSkills(source, url, options, spinner) {
 	spinner.start("Discovering skills from well-known endpoint...");
 	let skills = [];
@@ -4400,9 +4798,13 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 		process.exit(0);
 	}
 	let selectedSkills;
+	const logWellKnown = (chosen) => logAutoSelectedSkills(chosen.map((s) => ({
+		label: s.installName,
+		description: s.description
+	})));
 	if (options.skill?.includes("*")) {
 		selectedSkills = skills;
-		log.info(`Installing all ${skills.length} skills`);
+		logWellKnown(selectedSkills);
 	} else if (options.skill && options.skill.length > 0) {
 		selectedSkills = skills.filter((s) => options.skill.some((name) => s.installName.toLowerCase() === name.toLowerCase() || s.name.toLowerCase() === name.toLowerCase()));
 		if (selectedSkills.length === 0) {
@@ -4411,13 +4813,9 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 			for (const s of skills) log.message(`  - ${s.installName}`);
 			process.exit(1);
 		}
-	} else if (skills.length === 1) {
-		selectedSkills = skills;
-		const firstSkill = skills[0];
-		log.info(`Skill: ${import_picocolors.default.cyan(firstSkill.installName)}`);
-	} else if (options.yes) {
+	} else if (skills.length === 1 || options.yes) {
 		selectedSkills = skills;
-		log.info(`Installing all ${skills.length} skills`);
+		logWellKnown(selectedSkills);
 	} else {
 		const selected = await searchMultiselect({
 			message: "Select skills to install",
@@ -4726,15 +5124,26 @@ async function runAdd(args, options = {}) {
 	else if (!process.stdin.isTTY) showInstallTip();
 	let tempDir = null;
 	try {
+		let effectiveSource = source;
+		let notionSourceLabel = null;
+		const notionSkillPageId = parseNotionSkillUrl(source);
+		if (isNotionSource(source) || notionSkillPageId) {
+			const prepared = notionSkillPageId ? await prepareNotionSkillSource(notionSkillPageId) : await prepareNotionPackSource(options);
+			if (!prepared) return;
+			effectiveSource = prepared.rootDir;
+			tempDir = prepared.tempDir;
+			notionSourceLabel = "packCount" in prepared ? `${prepared.packCount} selected Notion pack${prepared.packCount === 1 ? "" : "s"}` : "Notion page";
+			options.skill = ["*"];
+		}
 		const spinner$3 = jsonMode ? {
 			start: () => {},
 			stop: () => {},
 			message: () => {}
 		} : spinner();
 		spinner$3.start("Parsing source…");
-		const parsed = parseSource(source);
-		let directDownload = parsed.type === "download";
-		spinner$3.stop(`Source: ${parsed.type === "local" ? parsed.localPath : parsed.url}${parsed.ref ? ` @ ${import_picocolors.default.yellow(parsed.ref)}` : ""}${parsed.subpath ? ` (${parsed.subpath})` : ""}${parsed.skillFilter ? ` ${import_picocolors.default.dim("@")}${import_picocolors.default.cyan(parsed.skillFilter)}` : ""}`);
+		const parsed = parseSource(effectiveSource);
+		let directDownload = parsed.type === "download" || notionSourceLabel !== null;
+		spinner$3.stop(notionSourceLabel !== null ? `Source: ${notionSourceLabel}` : `Source: ${parsed.type === "local" ? parsed.localPath : parsed.url}${parsed.ref ? ` @ ${import_picocolors.default.yellow(parsed.ref)}` : ""}${parsed.subpath ? ` (${parsed.subpath})` : ""}${parsed.skillFilter ? ` ${import_picocolors.default.dim("@")}${import_picocolors.default.cyan(parsed.skillFilter)}` : ""}`);
 		const ownerRepoRaw = parsed.type === "well-known" || parsed.type === "download" ? null : getOwnerRepo(parsed);
 		const repoPrivacyPromise = (() => {
 			if (parsed.type !== "github") return Promise.resolve(null);
@@ -4864,9 +5273,13 @@ async function runAdd(args, options = {}) {
 			emitJsonAndExit(0);
 		}
 		let selectedSkills;
+		const logChosen = (chosen) => logAutoSelectedSkills(chosen.map((s) => ({
+			label: getSkillDisplayName(s),
+			description: s.description
+		})));
 		if (options.skill?.includes("*")) {
 			selectedSkills = skills;
-			log.info(`Installing all ${skills.length} skills`);
+			logChosen(selectedSkills);
 		} else if (options.skill && options.skill.length > 0) {
 			selectedSkills = filterSkills(skills, options.skill);
 			if (jsonMode) {
@@ -4884,14 +5297,9 @@ async function runAdd(args, options = {}) {
 				emitJsonAndExit(1, `No matching skills found for: ${options.skill.join(", ")}`);
 			}
 			log.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => import_picocolors.default.cyan(getSkillDisplayName(s))).join(", ")}`);
-		} else if (skills.length === 1) {
-			selectedSkills = skills;
-			const firstSkill = skills[0];
-			log.info(`Skill: ${import_picocolors.default.cyan(getSkillDisplayName(firstSkill))}`);
-			log.message(import_picocolors.default.dim(firstSkill.description));
-		} else if (options.yes) {
+		} else if (skills.length === 1 || options.yes) {
 			selectedSkills = skills;
-			log.info(`Installing all ${skills.length} skills`);
+			logChosen(selectedSkills);
 		} else {
 			const sortedSkills = [...skills].sort((a, b) => {
 				if (a.pluginName && !b.pluginName) return -1;
@@ -7749,6 +8157,8 @@ ${BOLD}Usage:${RESET} skills <command> [options]
 ${BOLD}Manage Skills:${RESET}
   add <package>        Add a skill package (alias: a)
                        e.g. vercel-labs/agent-skills
+                            notion
+                            https://notion.so/<skill-page>
                             https://github.com/vercel-labs/agent-skills
   use <package>@<skill>
                        Generate a prompt for using one skill without installing it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills",
-  "version": "1.5.26",
+  "version": "1.7.0",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {