skills 1.5.20 → 1.5.21

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -85,8 +85,13 @@ npx skills add vercel-labs/agent-skills --skill '*' -a claude-code
 
 # Install specific skills to all agents
 npx skills add vercel-labs/agent-skills --agent '*' --skill frontend-design
+
+# Install from a direct SKILL.md or archive download URL
+npx skills add https://example.com/download/my-skill
 ```
 
+Direct download URLs are tried after well-known discovery. They may point to a single valid `SKILL.md` file or a `.zip`, `.tar`, `.tar.gz`, or `.tgz` archive; the URL does not need to include a file extension. Downloads are limited to 10 MiB, extracted content to 25 MiB, and archives to 1000 files by default. Override with `SKILLS_DOWNLOAD_MAX_BYTES`, `SKILLS_EXTRACT_MAX_BYTES`, and `SKILLS_EXTRACT_MAX_FILES` when you trust the source.
+
 ### Installation Scope
 
 | Scope       | Flag      | Location            | Use Case                                      |
@@ -542,4 +547,4 @@ Telemetry is automatically disabled in CI environments.
 
 ## License
 
-MIT
+This project is licensed under the [MIT License](LICENSE).

package/dist/_chunks/libs/@clack/prompts.mjs

@@ -1,6 +1,7 @@
 import { a, block, fastStringWidth, getColumns, getRows, n$1, r, require_src, settings, wrapAnsi, wrapTextWithPrefix } from "./core.mjs";
 import { styleText } from "node:util";
 import process$1 from "node:process";
+import "node:path";
 var import_src = require_src();
 function isUnicodeSupported() {
 	if (process$1.platform !== "win32") return process$1.env.TERM !== "linux";

package/dist/cli.mjs

@@ -10,6 +10,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
 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 { homedir, platform, tmpdir } from "os";
 import * as readline from "readline";
 import { Writable } from "stream";
@@ -18,8 +20,12 @@ import { execFile, execSync, 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 } 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 { createHash as createHash$1 } from "node:crypto";
-import { gunzipSync, inflateRawSync } from "node:zlib";
+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";
 var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
 const DEFAULT_GITHUB_HOST = "github.com";
 function getGitHubHost() {
@@ -38,7 +44,7 @@ function isGitHubHost(host) {
 	return normalizedHost === DEFAULT_GITHUB_HOST || normalizedHost === getGitHubHost().toLowerCase();
 }
 function getOwnerRepo(parsed) {
-	if (parsed.type === "local") return null;
+	if (parsed.type === "local" || parsed.type === "download") return null;
 	const sshMatch = parsed.url.match(/^git@[^:]+:(.+)$/);
 	if (sshMatch) {
 		let path = sshMatch[1];
@@ -133,6 +139,18 @@ function appendFragmentRef(input, ref, skillFilter) {
 	if (!ref) return input;
 	return `${input}#${ref}${skillFilter ? `@${skillFilter}` : ""}`;
 }
+function isHostedArtifactUrl(input) {
+	try {
+		const parsed = new URL(input);
+		const host = parsed.hostname.toLowerCase();
+		if (host === "raw.githubusercontent.com" || host === "codeload.github.com" || host === "objects.githubusercontent.com") return true;
+		if (host === "github.com") return /^\/[^/]+\/[^/]+\/(?:archive\/|raw\/|releases\/(?:download\/|latest\/download\/))/.test(parsed.pathname);
+		if (host === "gitlab.com") return /\/-\/(?:archive|raw)\//.test(parsed.pathname);
+		return false;
+	} catch {
+		return false;
+	}
+}
 function parseSource(input) {
 	if (isLocalPath(input)) {
 		const resolvedPath = resolve(input);
@@ -150,6 +168,10 @@ function parseSource(input) {
 	if (githubPrefixMatch) return parseSource(appendFragmentRef(githubPrefixMatch[1], fragmentRef, fragmentSkillFilter));
 	const gitlabPrefixMatch = input.match(/^gitlab:(.+)$/);
 	if (gitlabPrefixMatch) return parseSource(appendFragmentRef(`https://gitlab.com/${gitlabPrefixMatch[1]}`, fragmentRef, fragmentSkillFilter));
+	if (isHostedArtifactUrl(input)) return {
+		type: "download",
+		url: input
+	};
 	if (getGitHubHost() !== "github.com" && /^https?:\/\//.test(input)) try {
 		const parsedUrl = new URL(input);
 		if (isGitHubHost(parsedUrl.host) && parsedUrl.host !== "github.com") {
@@ -1904,13 +1926,13 @@ const SKILLS_SUBDIR = "skills";
 function sanitizeName(name) {
 	return name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "").substring(0, 255) || "unnamed-skill";
 }
-function isPathSafe$1(basePath, targetPath) {
+function isPathSafe$2(basePath, targetPath) {
 	const normalizedBase = normalize(resolve(basePath));
 	const normalizedTarget = normalize(resolve(targetPath));
 	return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
 }
 function pathsOverlap(pathA, pathB) {
-	return isPathSafe$1(pathA, pathB) || isPathSafe$1(pathB, pathA);
+	return isPathSafe$2(pathA, pathB) || isPathSafe$2(pathB, pathA);
 }
 async function isDirEntryOrSymlinkToDir(entry, entryPath) {
 	if (entry.isDirectory()) return true;
@@ -2004,13 +2026,13 @@ async function installSkillForAgent(skill, agentType, options = {}) {
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$2(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe$1(agentBase, agentDir)) return {
+	if (!isPathSafe$2(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -2147,7 +2169,7 @@ async function isSkillInstalled(skillName, agentType, options = {}) {
 	if (options.global && agent.globalSkillsDir === void 0) return false;
 	const targetBase = options.global ? agent.globalSkillsDir : agentType === "eve" && options.eveSubagent ? getEveSubagentSkillsDir(options.eveSubagent, options.cwd) : join(options.cwd || process.cwd(), agent.skillsDir);
 	const skillDir = join(targetBase, sanitized);
-	if (!isPathSafe$1(targetBase, skillDir)) return false;
+	if (!isPathSafe$2(targetBase, skillDir)) return false;
 	try {
 		await access(skillDir);
 		return true;
@@ -2161,14 +2183,14 @@ function getInstallPath(skillName, agentType, options = {}) {
 	const sanitized = sanitizeName(skillName);
 	const targetBase = getAgentBaseDir(agentType, options.global ?? false, options.cwd, options.eveSubagent);
 	const installPath = join(targetBase, sanitized);
-	if (!isPathSafe$1(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	if (!isPathSafe$2(targetBase, installPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return installPath;
 }
 function getCanonicalPath(skillName, options = {}) {
 	const sanitized = sanitizeName(skillName);
 	const canonicalBase = options.agent === "eve" ? getAgentBaseDir("eve", options.global ?? false, options.cwd, options.eveSubagent) : getCanonicalSkillsDir(options.global ?? false, options.cwd);
 	const canonicalPath = join(canonicalBase, sanitized);
-	if (!isPathSafe$1(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
+	if (!isPathSafe$2(canonicalBase, canonicalPath)) throw new Error("Invalid skill name: potential path traversal detected");
 	return canonicalPath;
 }
 async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
@@ -2188,13 +2210,13 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$2(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe$1(agentBase, agentDir)) return {
+	if (!isPathSafe$2(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -2203,7 +2225,7 @@ async function installWellKnownSkillForAgent(skill, agentType, options = {}) {
 	async function writeSkillFiles(targetDir) {
 		for (const [filePath, content] of skill.files) {
 			const fullPath = join(targetDir, filePath);
-			if (!isPathSafe$1(targetDir, fullPath)) continue;
+			if (!isPathSafe$2(targetDir, fullPath)) continue;
 			const parentDir = dirname(fullPath);
 			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
 			await writeFile(fullPath, agentType === "eve" && basename(filePath).toLowerCase() === "skill.md" && typeof content === "string" ? stripIgnoredEveFrontmatter(content) : content);
@@ -2269,7 +2291,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	const agentBase = getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent);
 	if (agentType === "eve" && !isEvePackagedSkill(skill.files)) {
 		const flatSkillPath = join(agentBase, toEveFlatSkillFileName(skill.installName));
-		if (!isPathSafe$1(agentBase, flatSkillPath)) return {
+		if (!isPathSafe$2(agentBase, flatSkillPath)) return {
 			success: false,
 			path: flatSkillPath,
 			mode: installMode,
@@ -2299,13 +2321,13 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	const canonicalBase = agentType === "eve" && installMode === "symlink" ? getAgentBaseDir(agentType, isGlobal, cwd, eveSubagent) : getCanonicalSkillsDir(isGlobal, cwd);
 	const canonicalDir = join(canonicalBase, skillName);
 	const agentDir = join(agentBase, skillName);
-	if (!isPathSafe$1(canonicalBase, canonicalDir)) return {
+	if (!isPathSafe$2(canonicalBase, canonicalDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
 		error: "Invalid skill name: potential path traversal detected"
 	};
-	if (!isPathSafe$1(agentBase, agentDir)) return {
+	if (!isPathSafe$2(agentBase, agentDir)) return {
 		success: false,
 		path: agentDir,
 		mode: installMode,
@@ -2314,7 +2336,7 @@ async function installBlobSkillForAgent(skill, agentType, options = {}) {
 	async function writeSkillFiles(targetDir) {
 		for (const file of skill.files) {
 			const fullPath = join(targetDir, file.path);
-			if (!isPathSafe$1(targetDir, fullPath)) continue;
+			if (!isPathSafe$2(targetDir, fullPath)) continue;
 			const parentDir = dirname(fullPath);
 			if (parentDir !== targetDir) await mkdir(parentDir, { recursive: true });
 			await writeFile(fullPath, agentType === "eve" && basename(file.path).toLowerCase() === "skill.md" ? stripIgnoredEveFrontmatter(file.contents) : file.contents, "utf-8");
@@ -2463,7 +2485,7 @@ async function listInstalledSkills(options = {}) {
 				]));
 				for (const possibleName of possibleNames) {
 					const agentSkillDir = join(agentBase, possibleName);
-					if (!isPathSafe$1(agentBase, agentSkillDir)) continue;
+					if (!isPathSafe$2(agentBase, agentSkillDir)) continue;
 					try {
 						await access(agentSkillDir);
 						found = true;
@@ -2475,7 +2497,7 @@ async function listInstalledSkills(options = {}) {
 					for (const agentEntry of agentEntries) {
 						const candidateDir = join(agentBase, agentEntry.name);
 						if (!await isDirEntryOrSymlinkToDir(agentEntry, candidateDir)) continue;
-						if (!isPathSafe$1(agentBase, candidateDir)) continue;
+						if (!isPathSafe$2(agentBase, candidateDir)) continue;
 						try {
 							const candidateSkillMd = join(candidateDir, "SKILL.md");
 							await stat(candidateSkillMd);
@@ -2615,9 +2637,220 @@ var ProviderRegistryImpl = class {
 	}
 };
 new ProviderRegistryImpl();
+const ZIP_LOCAL_FILE_HEADER = 67324752;
+const ZIP_CENTRAL_DIRECTORY_HEADER = 33639248;
+const ZIP_END_OF_CENTRAL_DIRECTORY = 101010256;
+const ZIP64_END_OF_CENTRAL_DIRECTORY = 101075792;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR = 117853008;
+const ZIP_END_MIN_SIZE = 22;
+const ZIP_MAX_COMMENT_SIZE = 65535;
+const CP437_HIGH_BYTES = [
+	"ÇüéâäàåçêëèïîìÄÅ",
+	"ÉæÆôöòûùÿÖÜ¢£¥₧ƒ",
+	"áíóúñѪº¿⌐¬½¼¡«»",
+	"░▒▓│┤╡╢╖╕╣║╗╝╜╛┐",
+	"└┴┬├─┼╞╟╚╔╩╦╠═╬╧",
+	"╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀",
+	"αßΓπΣσµτΦΘΩδ∞φε∩",
+	"≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\xA0"
+].join("");
+var ArchiveValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ArchiveValidationError";
+	}
+};
+function ensureRange(buffer, offset, length, label) {
+	if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset + length > buffer.length) throw new Error(`Invalid zip archive: ${label} is out of bounds`);
+}
+function findEndOfCentralDirectory(buffer) {
+	const minOffset = Math.max(0, buffer.length - ZIP_MAX_COMMENT_SIZE - ZIP_END_MIN_SIZE);
+	for (let offset = buffer.length - ZIP_END_MIN_SIZE; offset >= minOffset; offset--) {
+		if (buffer.readUInt32LE(offset) !== ZIP_END_OF_CENTRAL_DIRECTORY) continue;
+		const commentLength = buffer.readUInt16LE(offset + 20);
+		if (offset + ZIP_END_MIN_SIZE + commentLength === buffer.length) return offset;
+	}
+	return -1;
+}
+function readUInt64AsNumber(buffer, offset, label) {
+	ensureRange(buffer, offset, 8, label);
+	const value = buffer.readBigUInt64LE(offset);
+	if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error(`Invalid zip archive: ${label} exceeds the safe integer range`);
+	return Number(value);
+}
+function readCentralDirectory(buffer, endOffset) {
+	const diskNumber = buffer.readUInt16LE(endOffset + 4);
+	const centralDirectoryDisk = buffer.readUInt16LE(endOffset + 6);
+	const entriesOnDisk = buffer.readUInt16LE(endOffset + 8);
+	const totalEntries = buffer.readUInt16LE(endOffset + 10);
+	const size = buffer.readUInt32LE(endOffset + 12);
+	const offset = buffer.readUInt32LE(endOffset + 16);
+	if (!(entriesOnDisk === 65535 || totalEntries === 65535 || size === 4294967295 || offset === 4294967295)) {
+		if (diskNumber !== 0 || centralDirectoryDisk !== 0 || entriesOnDisk !== totalEntries) throw new Error("Multi-disk zip archives are not supported");
+		return {
+			entries: totalEntries,
+			offset,
+			size,
+			trailerOffset: endOffset
+		};
+	}
+	if (diskNumber !== 0 || centralDirectoryDisk !== 0) throw new Error("Multi-disk zip archives are not supported");
+	const locatorOffset = endOffset - 20;
+	ensureRange(buffer, locatorOffset, 20, "zip64 locator");
+	if (buffer.readUInt32LE(locatorOffset) !== ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR) throw new Error("Invalid zip64 locator");
+	if (buffer.readUInt32LE(locatorOffset + 4) !== 0 || buffer.readUInt32LE(locatorOffset + 16) !== 1) throw new Error("Multi-disk zip archives are not supported");
+	const zip64EndOffset = readUInt64AsNumber(buffer, locatorOffset + 8, "zip64 end offset");
+	ensureRange(buffer, zip64EndOffset, 56, "zip64 end of central directory");
+	if (buffer.readUInt32LE(zip64EndOffset) !== ZIP64_END_OF_CENTRAL_DIRECTORY) throw new Error("Invalid zip64 end of central directory");
+	const recordSize = readUInt64AsNumber(buffer, zip64EndOffset + 4, "zip64 end size");
+	if (recordSize < 44) throw new Error("Invalid zip64 end of central directory");
+	ensureRange(buffer, zip64EndOffset, recordSize + 12, "zip64 end of central directory");
+	if (zip64EndOffset + recordSize + 12 !== locatorOffset) throw new Error("Invalid zip64 end of central directory");
+	if (buffer.readUInt32LE(zip64EndOffset + 16) !== 0 || buffer.readUInt32LE(zip64EndOffset + 20) !== 0) throw new Error("Multi-disk zip archives are not supported");
+	const zip64EntriesOnDisk = readUInt64AsNumber(buffer, zip64EndOffset + 24, "zip64 entries on disk");
+	const zip64TotalEntries = readUInt64AsNumber(buffer, zip64EndOffset + 32, "zip64 total entries");
+	if (zip64EntriesOnDisk !== zip64TotalEntries) throw new Error("Multi-disk zip archives are not supported");
+	return {
+		entries: zip64TotalEntries,
+		size: readUInt64AsNumber(buffer, zip64EndOffset + 40, "zip64 central directory size"),
+		offset: readUInt64AsNumber(buffer, zip64EndOffset + 48, "zip64 central directory offset"),
+		trailerOffset: zip64EndOffset
+	};
+}
+function normalizeArchivePath(rawPath) {
+	if (!rawPath || rawPath.includes("\0")) return null;
+	const path = rawPath.replace(/\\/g, "/");
+	if (path.startsWith("/") || /^[A-Za-z]:/.test(path)) return null;
+	const parts = path.split("/");
+	if (parts.some((part) => part === "..")) return null;
+	const normalized = parts.filter((part) => part && part !== ".").join("/");
+	if (!normalized && !path.endsWith("/")) return null;
+	return path.endsWith("/") && normalized ? `${normalized}/` : normalized;
+}
+function findExtraField(buffer, extraOffset, extraLength, targetId) {
+	const extraEnd = extraOffset + extraLength;
+	let offset = extraOffset;
+	while (offset < extraEnd) {
+		if (offset + 4 > extraEnd) throw new Error("Invalid zip extra field");
+		const id = buffer.readUInt16LE(offset);
+		const size = buffer.readUInt16LE(offset + 2);
+		const dataOffset = offset + 4;
+		ensureRange(buffer, dataOffset, size, "zip extra field");
+		if (dataOffset + size > extraEnd) throw new Error("Invalid zip extra field");
+		if (id === targetId) return buffer.subarray(dataOffset, dataOffset + size);
+		offset = dataOffset + size;
+	}
+	return null;
+}
+function decodeFileName(bytes, isUtf8, unicodePathExtra) {
+	if (isUtf8) return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	if (unicodePathExtra && unicodePathExtra.length >= 5 && unicodePathExtra[0] === 1 && unicodePathExtra.readUInt32LE(1) === crc32(bytes)) return new TextDecoder("utf-8", { fatal: true }).decode(unicodePathExtra.subarray(5));
+	let result = "";
+	for (const byte of bytes) result += byte < 128 ? String.fromCharCode(byte) : CP437_HIGH_BYTES[byte - 128];
+	return result;
+}
+function readZip64EntryValues(buffer, extraOffset, extraLength, values) {
+	if (!(values.uncompressedSize === 4294967295 || values.compressedSize === 4294967295 || values.localHeaderOffset === 4294967295 || values.diskStart === 65535)) {
+		if (values.diskStart !== 0) throw new Error("Multi-disk zip archives are not supported");
+		return values;
+	}
+	const zip64Extra = findExtraField(buffer, extraOffset, extraLength, 1);
+	if (!zip64Extra) throw new Error("Invalid zip64 extra field");
+	let valueOffset = 0;
+	const readNextUInt64 = (label) => {
+		if (valueOffset + 8 > zip64Extra.length) throw new Error(`Invalid zip64 extra field: missing ${label}`);
+		const value = readUInt64AsNumber(zip64Extra, valueOffset, `zip64 ${label}`);
+		valueOffset += 8;
+		return value;
+	};
+	const resolved = { ...values };
+	if (resolved.uncompressedSize === 4294967295) resolved.uncompressedSize = readNextUInt64("uncompressed size");
+	if (resolved.compressedSize === 4294967295) resolved.compressedSize = readNextUInt64("compressed size");
+	if (resolved.localHeaderOffset === 4294967295) resolved.localHeaderOffset = readNextUInt64("local header offset");
+	if (resolved.diskStart === 65535) {
+		if (valueOffset + 4 > zip64Extra.length) throw new Error("Invalid zip64 extra field: missing disk start");
+		resolved.diskStart = zip64Extra.readUInt32LE(valueOffset);
+	}
+	if (resolved.diskStart !== 0) throw new Error("Multi-disk zip archives are not supported");
+	return resolved;
+}
+function readZipArchive(bytes, limits) {
+	const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const endOffset = findEndOfCentralDirectory(buffer);
+	if (endOffset < 0) throw new Error("Invalid zip archive");
+	const centralDirectory = readCentralDirectory(buffer, endOffset);
+	const totalEntries = centralDirectory.entries;
+	if (totalEntries > limits.maxEntries) throw new ArchiveValidationError(`Archive contains too many files (${totalEntries}). Maximum is ${limits.maxEntries}.`);
+	ensureRange(buffer, centralDirectory.offset, centralDirectory.size, "central directory");
+	if (centralDirectory.offset + centralDirectory.size > centralDirectory.trailerOffset) throw new Error("Invalid zip archive: central directory overlaps archive trailer");
+	const files = /* @__PURE__ */ new Map();
+	let extractedBytes = 0;
+	let offset = centralDirectory.offset;
+	for (let index = 0; index < totalEntries; index++) {
+		ensureRange(buffer, offset, 46, "central directory entry");
+		if (buffer.readUInt32LE(offset) !== ZIP_CENTRAL_DIRECTORY_HEADER) throw new Error("Invalid zip central directory entry");
+		const flags = buffer.readUInt16LE(offset + 8);
+		const method = buffer.readUInt16LE(offset + 10);
+		const expectedChecksum = buffer.readUInt32LE(offset + 16);
+		let compressedSize = buffer.readUInt32LE(offset + 20);
+		let uncompressedSize = buffer.readUInt32LE(offset + 24);
+		const fileNameLength = buffer.readUInt16LE(offset + 28);
+		const extraLength = buffer.readUInt16LE(offset + 30);
+		const commentLength = buffer.readUInt16LE(offset + 32);
+		let diskStart = buffer.readUInt16LE(offset + 34);
+		const externalAttributes = buffer.readUInt32LE(offset + 38);
+		let localHeaderOffset = buffer.readUInt32LE(offset + 42);
+		const variableSize = fileNameLength + extraLength + commentLength;
+		ensureRange(buffer, offset + 46, variableSize, "central directory entry data");
+		const nameStart = offset + 46;
+		const extraOffset = nameStart + fileNameLength;
+		({compressedSize, diskStart, localHeaderOffset, uncompressedSize} = readZip64EntryValues(buffer, extraOffset, extraLength, {
+			compressedSize,
+			diskStart,
+			localHeaderOffset,
+			uncompressedSize
+		}));
+		const centralFileName = buffer.subarray(nameStart, nameStart + fileNameLength);
+		const rawFileName = decodeFileName(centralFileName, Boolean(flags & 2048), findExtraField(buffer, extraOffset, extraLength, 28789));
+		const fileName = normalizeArchivePath(rawFileName);
+		if (fileName === null) throw new ArchiveValidationError(`Archive contains unsafe path: ${rawFileName}`);
+		if (flags & 1) throw new ArchiveValidationError("Encrypted zip entries are not supported");
+		const fileType = externalAttributes >>> 16 & 61440;
+		if (fileType !== 0 && fileType !== 32768 && fileType !== 16384) throw new ArchiveValidationError("Archive links are not supported");
+		const isDirectory = rawFileName.replace(/\\/g, "/").endsWith("/") || fileType === 16384;
+		offset += 46 + variableSize;
+		extractedBytes += uncompressedSize;
+		if (extractedBytes > limits.maxExtractedBytes) throw new ArchiveValidationError(`Archive extracts to more than ${limits.maxExtractedBytes} bytes.`);
+		if (isDirectory) continue;
+		ensureRange(buffer, localHeaderOffset, 30, "local file header");
+		if (buffer.readUInt32LE(localHeaderOffset) !== ZIP_LOCAL_FILE_HEADER) throw new Error("Invalid zip local file header");
+		const localFlags = buffer.readUInt16LE(localHeaderOffset + 6);
+		const localMethod = buffer.readUInt16LE(localHeaderOffset + 8);
+		const localFileNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+		const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+		const localNameOffset = localHeaderOffset + 30;
+		ensureRange(buffer, localNameOffset, localFileNameLength + localExtraLength, "local file header data");
+		const localFileName = buffer.subarray(localNameOffset, localNameOffset + localFileNameLength);
+		if (localFlags !== flags || localMethod !== method || !localFileName.equals(centralFileName)) throw new Error("Zip local header does not match central directory");
+		const dataOffset = localHeaderOffset + 30 + localFileNameLength + localExtraLength;
+		ensureRange(buffer, dataOffset, compressedSize, "file data");
+		if (dataOffset + compressedSize > centralDirectory.offset) throw new Error("Invalid zip archive: file data overlaps central directory");
+		const compressed = buffer.subarray(dataOffset, dataOffset + compressedSize);
+		let contents;
+		if (method === 0) contents = compressed;
+		else if (method === 8) contents = inflateRawSync(compressed, { maxOutputLength: uncompressedSize + 1 });
+		else throw new Error(`Unsupported zip compression method: ${method}`);
+		if (contents.byteLength !== uncompressedSize) throw new Error("Zip entry size mismatch");
+		if (crc32(contents) !== expectedChecksum) throw new Error("Zip entry checksum mismatch");
+		files.set(fileName, new Uint8Array(contents));
+	}
+	if (offset !== centralDirectory.offset + centralDirectory.size) throw new Error("Invalid zip central directory size");
+	return files;
+}
 const DISCOVERY_SCHEMA_V2 = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
 const MAX_ARCHIVE_UNPACKED_BYTES = 50 * 1024 * 1024;
 const MAX_ARCHIVE_FILES = 1e3;
+const DISCOVERY_TIMEOUT_MS = 1e4;
 var WellKnownProvider = class {
 	id = "well-known";
 	displayName = "Well-Known Skills";
@@ -2647,6 +2880,7 @@ var WellKnownProvider = class {
 		try {
 			const parsed = new URL(baseUrl);
 			const basePath = parsed.pathname.replace(/\/$/, "");
+			const signal = AbortSignal.timeout(DISCOVERY_TIMEOUT_MS);
 			const urlsToTry = [];
 			for (const wellKnownPath of this.WELL_KNOWN_PATHS) {
 				urlsToTry.push({
@@ -2662,7 +2896,7 @@ var WellKnownProvider = class {
 			}
 			const candidates = [];
 			for (const { indexUrl, baseUrl: resolvedBase, wellKnownPath } of urlsToTry) try {
-				const response = await fetch(indexUrl);
+				const response = await fetch(indexUrl, { signal });
 				if (!response.ok) continue;
 				const rawIndex = await response.json();
 				const normalized = this.normalizeIndex(rawIndex, indexUrl, wellKnownPath);
@@ -2929,7 +3163,10 @@ var WellKnownProvider = class {
 		return `sha256:${createHash$1("sha256").update(bytes).digest("hex")}`;
 	}
 	extractArchive(bytes, artifactUrl, contentType) {
-		if (this.isZipArchive(bytes, artifactUrl, contentType)) return this.extractZip(bytes);
+		if (this.isZipArchive(bytes, artifactUrl, contentType)) return new Map(readZipArchive(bytes, {
+			maxExtractedBytes: MAX_ARCHIVE_UNPACKED_BYTES,
+			maxEntries: MAX_ARCHIVE_FILES
+		}));
 		if (this.isTarGzArchive(bytes, artifactUrl, contentType)) return this.extractTarGz(bytes);
 		throw new Error("Unsupported archive format");
 	}
@@ -2989,54 +3226,6 @@ var WellKnownProvider = class {
 		const nul = slice.indexOf(0);
 		return new TextDecoder().decode(nul >= 0 ? slice.subarray(0, nul) : slice);
 	}
-	extractZip(bytes) {
-		const buffer = Buffer.from(bytes);
-		const eocdOffset = this.findZipEndOfCentralDirectory(buffer);
-		if (eocdOffset < 0) throw new Error("Invalid zip archive");
-		const totalEntries = buffer.readUInt16LE(eocdOffset + 10);
-		const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + 16);
-		const files = /* @__PURE__ */ new Map();
-		const runningTotal = { bytes: 0 };
-		let offset = centralDirectoryOffset;
-		for (let i = 0; i < totalEntries; i++) {
-			if (buffer.readUInt32LE(offset) !== 33639248) throw new Error("Invalid zip directory");
-			const flags = buffer.readUInt16LE(offset + 8);
-			const method = buffer.readUInt16LE(offset + 10);
-			const compressedSize = buffer.readUInt32LE(offset + 20);
-			const uncompressedSize = buffer.readUInt32LE(offset + 24);
-			const fileNameLength = buffer.readUInt16LE(offset + 28);
-			const extraLength = buffer.readUInt16LE(offset + 30);
-			const commentLength = buffer.readUInt16LE(offset + 32);
-			const externalAttributes = buffer.readUInt32LE(offset + 38);
-			const localHeaderOffset = buffer.readUInt32LE(offset + 42);
-			const nameStart = offset + 46;
-			const rawName = buffer.subarray(nameStart, nameStart + fileNameLength);
-			const fileName = new TextDecoder(flags & 2048 ? "utf-8" : void 0).decode(rawName);
-			offset = nameStart + fileNameLength + extraLength + commentLength;
-			if (fileName.endsWith("/")) continue;
-			if (flags & 1) throw new Error("Encrypted zip entries are not supported");
-			const fileType = externalAttributes >>> 16 & 61440;
-			if (fileType === 40960 || fileType === 4096) throw new Error("Archive links are not supported");
-			if (buffer.readUInt32LE(localHeaderOffset) !== 67324752) throw new Error("Invalid zip local header");
-			const localFileNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
-			const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
-			const dataStart = localHeaderOffset + 30 + localFileNameLength + localExtraLength;
-			const compressed = buffer.subarray(dataStart, dataStart + compressedSize);
-			let content;
-			if (method === 0) content = compressed;
-			else if (method === 8) content = inflateRawSync(compressed);
-			else throw new Error(`Unsupported zip compression method: ${method}`);
-			if (content.byteLength !== uncompressedSize) throw new Error("Zip entry size mismatch");
-			this.addArchiveFile(files, fileName, new Uint8Array(content), runningTotal);
-		}
-		if (!files.has("SKILL.md")) throw new Error("Archive missing root SKILL.md");
-		return files;
-	}
-	findZipEndOfCentralDirectory(buffer) {
-		const minOffset = Math.max(0, buffer.length - 65535 - 22);
-		for (let offset = buffer.length - 22; offset >= minOffset; offset--) if (buffer.readUInt32LE(offset) === 101010256) return offset;
-		return -1;
-	}
 	toRawUrl(url) {
 		try {
 			const parsed = new URL(url);
@@ -3065,6 +3254,187 @@ var WellKnownProvider = class {
 	}
 };
 const wellKnownProvider = new WellKnownProvider();
+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 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() {
+	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)
+	};
+}
+function isPathSafe$1(basePath, targetPath) {
+	const normalizedBase = normalize$1(resolve$1(basePath));
+	const normalizedTarget = normalize$1(resolve$1(targetPath));
+	return normalizedTarget.startsWith(normalizedBase + sep$1) || normalizedTarget === normalizedBase;
+}
+function validateArchivePath(path) {
+	const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
+	if (!normalized || normalized.endsWith("/")) return normalized;
+	if (normalized.startsWith("/") || /^[a-zA-Z]:\//.test(normalized)) return null;
+	if (normalized.split("/").includes("..")) return null;
+	return normalized;
+}
+function incrementEntry(state, size, limits) {
+	state.entries += 1;
+	if (state.entries > limits.extractMaxFiles) throw new ArchiveValidationError(`Archive contains too many files (${state.entries}). Maximum is ${limits.extractMaxFiles}. Set SKILLS_EXTRACT_MAX_FILES to override.`);
+	state.bytes += size;
+	if (state.bytes > limits.extractMaxBytes) throw new ArchiveValidationError(`Archive extracts to more than ${limits.extractMaxBytes} bytes. Set SKILLS_EXTRACT_MAX_BYTES to override.`);
+}
+async function downloadToFile(url, targetFile, limits) {
+	const response = await fetch(url, {
+		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+		redirect: "follow"
+	});
+	if (!response.ok) throw new Error(`Download failed with HTTP ${response.status}`);
+	const contentLength = response.headers.get("content-length");
+	if (contentLength) {
+		const parsed = Number.parseInt(contentLength, 10);
+		if (Number.isFinite(parsed) && parsed > limits.downloadMaxBytes) throw new Error(`Download is larger than ${limits.downloadMaxBytes} bytes. Set SKILLS_DOWNLOAD_MAX_BYTES to override.`);
+	}
+	if (!response.body) throw new Error("Download response has no body");
+	let downloaded = 0;
+	const limitStream = new TransformStream({ transform(chunk, controller) {
+		downloaded += chunk.byteLength;
+		if (downloaded > limits.downloadMaxBytes) throw new Error(`Download is larger than ${limits.downloadMaxBytes} bytes. Set SKILLS_DOWNLOAD_MAX_BYTES to override.`);
+		controller.enqueue(chunk);
+	} });
+	await pipeline(response.body.pipeThrough(limitStream), createWriteStream(targetFile));
+}
+async function isValidSkillMarkdown(filePath) {
+	try {
+		const { data } = parseFrontmatter(await readFile$1(filePath, "utf-8"));
+		return typeof data.name === "string" && typeof data.description === "string";
+	} catch {
+		return false;
+	}
+}
+async function extractZip(filePath, extractDir, limits) {
+	const files = readZipArchive(await readFile$1(filePath), {
+		maxExtractedBytes: limits.extractMaxBytes,
+		maxEntries: limits.extractMaxFiles
+	});
+	for (const [path, contents] of files) {
+		const targetPath = join$1(extractDir, path);
+		if (!isPathSafe$1(extractDir, targetPath)) throw new ArchiveValidationError(`Archive contains unsafe path: ${path}`);
+		await mkdir$1(dirname$1(targetPath), { recursive: true });
+		await writeFile$1(targetPath, contents);
+	}
+}
+function getTarEntryType(entry) {
+	if (entry instanceof tar.ReadEntry) return entry.type;
+	if (entry.isFile()) return "File";
+	if (entry.isDirectory()) return "Directory";
+	return "";
+}
+function isTarEntryFile(entry) {
+	const type = getTarEntryType(entry);
+	return type === "File" || type === "OldFile" || type === "ContiguousFile";
+}
+async function extractTar(filePath, extractDir, limits) {
+	const state = {
+		bytes: 0,
+		entries: 0
+	};
+	let validationError;
+	await tar.x({
+		strict: true,
+		filter(entryPath, entry) {
+			if (validationError) return false;
+			try {
+				const safePath = validateArchivePath(entryPath);
+				if (safePath === null) throw new ArchiveValidationError(`Archive contains unsafe path: ${entryPath}`);
+				if (!isPathSafe$1(extractDir, join$1(extractDir, safePath))) throw new ArchiveValidationError(`Archive contains unsafe path: ${entryPath}`);
+				incrementEntry(state, entry.size, limits);
+				if (isTarEntryFile(entry)) return true;
+				return getTarEntryType(entry) === "Directory";
+			} catch (error) {
+				if (error instanceof ArchiveValidationError) {
+					validationError = error;
+					return false;
+				}
+				throw error;
+			}
+		},
+		cwd: extractDir,
+		preservePaths: false,
+		noChmod: true,
+		file: filePath
+	});
+	if (validationError) throw validationError;
+}
+async function tryExtractArchive(filePath, extractDir, limits) {
+	const header = await readFile$1(filePath).then((buffer) => buffer.subarray(0, 512));
+	const isZip = header[0] === 80 && header[1] === 75;
+	const isGzip = header[0] === 31 && header[1] === 139;
+	try {
+		if (isZip) {
+			await extractZip(filePath, extractDir, limits);
+			return true;
+		}
+		if (isGzip) {
+			await extractTar(filePath, extractDir, limits);
+			return true;
+		}
+		await extractTar(filePath, extractDir, limits);
+		return true;
+	} catch (error) {
+		await rm$1(extractDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		await mkdir$1(extractDir, { recursive: true });
+		if (error instanceof ArchiveValidationError) throw error;
+		return false;
+	}
+}
+async function getSingleTopLevelDirectory(dir) {
+	const { readdir } = await import("node:fs/promises");
+	const visibleEntries = (await readdir(dir, { withFileTypes: true })).filter((entry) => entry.name !== "__MACOSX");
+	if (visibleEntries.length !== 1 || !visibleEntries[0].isDirectory()) return null;
+	return join$1(dir, visibleEntries[0].name);
+}
+async function downloadSource(url) {
+	const limits = getDownloadLimits();
+	const tempDir = await mkdtemp$1(join$1(tmpdir$1(), "skills-download-"));
+	const downloadedFile = join$1(tempDir, "source.download");
+	const extractDir = join$1(tempDir, "extract");
+	try {
+		await downloadToFile(url, downloadedFile, limits);
+		if ((await stat$1(downloadedFile)).size === 0) throw new Error("Downloaded URL is empty");
+		if (await isValidSkillMarkdown(downloadedFile)) {
+			const skillDir = join$1(tempDir, "skill");
+			await mkdir$1(skillDir, { recursive: true });
+			await writeFile$1(join$1(skillDir, "SKILL.md"), await readFile$1(downloadedFile));
+			return {
+				rootDir: skillDir,
+				tempDir,
+				kind: "skill-md"
+			};
+		}
+		await mkdir$1(extractDir, { recursive: true });
+		if (await tryExtractArchive(downloadedFile, extractDir, limits)) return {
+			rootDir: await getSingleTopLevelDirectory(extractDir) ?? extractDir,
+			tempDir,
+			kind: "archive"
+		};
+		throw new Error("Downloaded URL is not a valid SKILL.md file or supported archive");
+	} catch (error) {
+		await rm$1(tempDir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		throw error;
+	}
+}
 const AGENTS_DIR = ".agents";
 const LOCK_FILE = ".skill-lock.json";
 const CURRENT_VERSION = 3;
@@ -3431,7 +3801,7 @@ async function tryBlobInstall(ownerRepo, options = {}) {
 		tree
 	};
 }
-var version$1 = "1.5.20";
+var version$1 = "1.5.21";
 const isCancelled$1 = (value) => typeof value === "symbol";
 const EVE_AGENT_LABEL = "eve agent";
 async function isSourcePrivate(source) {
@@ -3651,12 +4021,11 @@ async function selectAgentsInteractive(options) {
 }
 setVersion(version$1);
 async function handleWellKnownSkills(source, url, options, spinner) {
-	spinner.start("Discovering skills from well-known endpoint…");
-	const skills = await wellKnownProvider.fetchAllSkills(url);
+	spinner.start("Discovering skills from well-known endpoint...");
+	const skills = await wellKnownProvider.fetchAllSkills(url).catch(() => []);
 	if (skills.length === 0) {
-		spinner.stop(import_picocolors.default.red("No skills found"));
-		outro(import_picocolors.default.red("No skills found at this URL. Make sure the server has a /.well-known/agent-skills/index.json or /.well-known/skills/index.json file."));
-		process.exit(1);
+		spinner.stop(import_picocolors.default.dim("No well-known skills found; trying direct download..."));
+		return false;
 	}
 	spinner.stop(`Found ${import_picocolors.default.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
 	for (const skill of skills) {
@@ -3861,6 +4230,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 		agents: targetAgents.join(","),
 		...installGlobally && { global: "1" },
 		skillFiles: JSON.stringify(skillFiles),
+		installUrl: url,
 		metadata: options.metadata,
 		sourceType: "well-known"
 	});
@@ -3936,6 +4306,7 @@ async function handleWellKnownSkills(source, url, options, spinner) {
 	console.log();
 	outro(import_picocolors.default.green("Done!") + import_picocolors.default.dim("  Review skills before use; they run with full agent permissions."));
 	await promptForFindSkills(options, targetAgents);
+	return true;
 }
 async function runAdd(args, options = {}) {
 	const source = args[0];
@@ -3979,8 +4350,9 @@ async function runAdd(args, options = {}) {
 		const spinner$3 = 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 ownerRepoRaw = getOwnerRepo(parsed);
+		const ownerRepoRaw = parsed.type === "well-known" || parsed.type === "download" ? null : getOwnerRepo(parsed);
 		const repoPrivacyPromise = (() => {
 			if (parsed.type !== "github") return Promise.resolve(null);
 			if (!ownerRepoRaw) return Promise.resolve(null);
@@ -3989,8 +4361,8 @@ async function runAdd(args, options = {}) {
 			return isRepoPrivate(ownerRepo.owner, ownerRepo.repo).catch(() => null);
 		})();
 		if (parsed.type === "well-known") {
-			await handleWellKnownSkills(source, parsed.url, options, spinner$3);
-			return;
+			if (await handleWellKnownSkills(source, parsed.url, options, spinner$3)) return;
+			directDownload = true;
 		}
 		if (parsed.skillFilter) {
 			options.skill = options.skill || [];
@@ -4012,6 +4384,16 @@ async function runAdd(args, options = {}) {
 				includeInternal,
 				fullDepth: options.fullDepth
 			});
+		} else if (parsed.type === "well-known" || parsed.type === "download") {
+			spinner$3.start("Downloading source...");
+			const downloaded = await downloadSource(parsed.url);
+			tempDir = downloaded.tempDir;
+			spinner$3.stop(`Downloaded ${downloaded.kind === "skill-md" ? "SKILL.md file" : "archive"}`);
+			spinner$3.start("Discovering skills...");
+			skills = await discoverSkills(downloaded.rootDir, parsed.subpath, {
+				includeInternal,
+				fullDepth: options.fullDepth
+			});
 		} else if (parsed.type === "github" && !options.fullDepth) {
 			const BLOB_ALLOWED_OWNERS = [
 				"vercel",
@@ -4404,9 +4786,9 @@ async function runAdd(args, options = {}) {
 		else if (tempDir && skill.path === tempDir) skillFiles[skill.name] = "SKILL.md";
 		else if (tempDir && skill.path.startsWith(tempDir + sep)) skillFiles[skill.name] = skill.path.slice(tempDir.length + 1).split(sep).join("/") + "/SKILL.md";
 		else continue;
-		const normalizedSource = getOwnerRepo(parsed);
-		const lockSource = getLockSource(parsed.url, normalizedSource);
-		const projectLockSourceUrl = getProjectLockSourceUrl(parsed.type, parsed.url);
+		const normalizedSource = directDownload ? null : getOwnerRepo(parsed);
+		const lockSource = directDownload ? null : getLockSource(parsed.url, normalizedSource);
+		const projectLockSourceUrl = directDownload ? void 0 : getProjectLockSourceUrl(parsed.type, parsed.url);
 		if (normalizedSource) if (parseOwnerRepo(normalizedSource)) {
 			if (await repoPrivacyPromise === false) track({
 				event: "install",
@@ -4457,7 +4839,7 @@ async function runAdd(args, options = {}) {
 				} catch {}
 			}
 		}
-		if (successful.length > 0 && !installGlobally) {
+		if (successful.length > 0 && !installGlobally && !directDownload) {
 			const successfulSkillNames = new Set(successful.map((r) => r.skill));
 			const eveSubagents = targetAgents.includes("eve") ? eveSubagentTargets.map((s) => s ?? "") : void 0;
 			const recordSubagents = eveSubagents && (eveSubagents.length > 1 || eveSubagents.some((s) => s !== ""));
@@ -6321,11 +6703,35 @@ async function runUse(sourceArgs, options = {}, parseErrors = []) {
 		const selector = resolveSelector(parsed.skillFilter, options.skill);
 		const includeInternal = selector !== void 0;
 		let selectedSkill;
-		if (parsed.type === "well-known") selectedSkill = selectWellKnownSkill(await wellKnownProvider.fetchAllSkills(parsed.url), selector, source);
-		else {
+		if (parsed.type === "well-known") {
+			const skills = await wellKnownProvider.fetchAllSkills(parsed.url);
+			if (skills.length > 0) selectedSkill = selectWellKnownSkill(skills, selector, source);
+			else {
+				const downloaded = await downloadSource(parsed.url);
+				cloneTempDir = downloaded.tempDir;
+				const selected = selectSkill(await discoverSkills(downloaded.rootDir, void 0, {
+					includeInternal,
+					fullDepth: options.fullDepth
+				}), selector, source);
+				selectedSkill = {
+					kind: "disk",
+					name: selected.name,
+					directoryName: selected.name,
+					rawContent: selected.rawContent,
+					path: selected.path
+				};
+			}
+		} else {
 			let skills;
 			let blobResult = null;
-			if (parsed.type === "local") {
+			if (parsed.type === "download") {
+				const downloaded = await downloadSource(parsed.url);
+				cloneTempDir = downloaded.tempDir;
+				skills = await discoverSkills(downloaded.rootDir, void 0, {
+					includeInternal,
+					fullDepth: options.fullDepth
+				});
+			} else if (parsed.type === "local") {
 				if (!existsSync(parsed.localPath)) fail(`Local path does not exist: ${parsed.localPath}`);
 				skills = await discoverSkills(parsed.localPath, parsed.subpath, {
 					includeInternal,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills",
-  "version": "1.5.20",
+  "version": "1.5.21",
   "description": "The open agent skills ecosystem",
   "type": "module",
   "bin": {
@@ -142,6 +142,7 @@
   },
   "packageManager": "pnpm@10.17.1",
   "dependencies": {
+    "tar": "^7.5.20",
     "yaml": "^2.8.3"
   }
 }