@localskills/cli 0.11.0 → 0.11.2

package/dist/index.js

@@ -5,13 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x3) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x3, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x3)(function(x3) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x3 + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   try {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   } catch (e2) {
@@ -1400,6 +1394,9 @@ var ApiClient = class {
     }
     return h;
   }
+  authHeader() {
+    return this.token ? { Authorization: `Bearer ${this.token}` } : {};
+  }
   async handleResponse(res) {
     if (res.status === 401) {
       return {
@@ -1409,19 +1406,45 @@ var ApiClient = class {
     }
     return res.json();
   }
+  /** Turn a transport-level rejection (offline, DNS, TLS, reset, bad body) into a failure response. */
+  transportError(err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { success: false, error: `Network error: ${detail}`, networkError: true };
+  }
   async get(path) {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      headers: this.headers()
-    });
-    return this.handleResponse(res);
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        headers: this.headers()
+      });
+      return await this.handleResponse(res);
+    } catch (err) {
+      return this.transportError(err);
+    }
   }
   async post(path, body) {
-    const res = await fetch(`${this.baseUrl}${path}`, {
-      method: "POST",
-      headers: this.headers(),
-      body: body ? JSON.stringify(body) : void 0
-    });
-    return this.handleResponse(res);
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: this.headers(),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      return await this.handleResponse(res);
+    } catch (err) {
+      return this.transportError(err);
+    }
+  }
+  async postForm(path, form) {
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        // No Content-Type — fetch sets the multipart/form-data boundary.
+        headers: this.authHeader(),
+        body: form
+      });
+      return await this.handleResponse(res);
+    } catch (err) {
+      return this.transportError(err);
+    }
   }
   async fetchBinary(url) {
     const headers = {};
@@ -1587,7 +1610,8 @@ var whoamiCommand = new Command("whoami").description("Show current user info").
 
 // src/commands/install.ts
 import { Command as Command2 } from "commander";
-import { mkdirSync as mkdirSync7 } from "fs";
+import { mkdirSync as mkdirSync7, rmSync as rmSync4, cpSync } from "fs";
+import { dirname as dirname5 } from "path";
 
 // ../../packages/shared/dist/utils/semver.js
 var SEMVER_RE = /^\d+\.\d+\.\d+$/;
@@ -1624,6 +1648,10 @@ function isGreaterThan(next, prev) {
 }
 
 // ../../packages/shared/dist/utils/index.js
+var PACKAGE_MAX_COMPRESSED_BYTES = 1 * 1024 * 1024;
+var PACKAGE_MAX_DECOMPRESSED_BYTES = 1 * 1024 * 1024;
+var PACKAGE_MAX_FILE_COUNT = 500;
+var PACKAGE_PREVIEW_BYTES = 2048;
 function titleFromSlug(slug) {
   return slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
@@ -1660,13 +1688,13 @@ function cancelGuard(value) {
 // src/lib/cache.ts
 import {
   existsSync as existsSync13,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   readFileSync as readFileSync4,
-  readdirSync,
-  writeFileSync as writeFileSync5,
+  readdirSync as readdirSync2,
+  writeFileSync as writeFileSync6,
   rmSync as rmSync3
 } from "fs";
-import { join as join12, resolve as resolve2 } from "path";
+import { join as join13, resolve as resolve3 } from "path";
 import { homedir as homedir8 } from "os";
 
 // src/lib/installers/cursor.ts
@@ -1722,9 +1750,10 @@ import {
   lstatSync,
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
-  rmSync
+  rmSync,
+  readlinkSync
 } from "fs";
-import { dirname, resolve } from "path";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
 function createSymlink(targetPath, linkPath) {
   const absTarget = resolve(targetPath);
   const absLink = resolve(linkPath);
@@ -1753,6 +1782,17 @@ function isSymlink(path) {
     return false;
   }
 }
+function isSymlinkInto(linkPath, dir) {
+  try {
+    if (!lstatSync(linkPath).isSymbolicLink()) return false;
+    const target = resolve(dirname(linkPath), readlinkSync(linkPath));
+    const base = resolve(dir);
+    const rel = relative(base, target);
+    return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/installers/common.ts
 function safeSlugName(slug) {
@@ -1828,7 +1868,7 @@ var cursorAdapter = {
 };
 
 // src/lib/installers/claude.ts
-import { existsSync as existsSync5, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync5, rmSync as rmSync2, statSync, readdirSync } from "fs";
 import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
 var descriptor2 = {
@@ -1847,14 +1887,20 @@ function detect2(projectDir) {
     project: existsSync5(join4(cwd, ".claude"))
   };
 }
+function claudeBase(scope, projectDir) {
+  return scope === "global" ? join4(homedir3(), ".claude") : join4(projectDir || process.cwd(), ".claude");
+}
 function resolvePath2(slug, scope, projectDir, contentType) {
   const safeName = safeSlugName(slug);
-  const base = scope === "global" ? join4(homedir3(), ".claude") : join4(projectDir || process.cwd(), ".claude");
+  const base = claudeBase(scope, projectDir);
   if (contentType === "rule") {
     return join4(base, "rules", `${safeName}.md`);
   }
   return join4(base, "skills", safeName, "SKILL.md");
 }
+function resolvePackageDir(slug, scope, projectDir, _contentType) {
+  return join4(claudeBase(scope, projectDir), "skills", safeSlugName(slug));
+}
 function transformContent2(content, skill) {
   if (skill.type === "rule") {
     return toPlainMD(content);
@@ -1866,11 +1912,19 @@ function install2(opts) {
   return installFileOrSymlink(opts, targetPath);
 }
 function uninstall2(installation, _slug) {
-  uninstallFile(installation);
-  const parentDir = join4(installation.path, "..");
+  const target = installation.path;
+  if (isSymlink(target)) {
+    removeSymlink(target);
+  } else if (existsSync5(target)) {
+    if (statSync(target).isDirectory()) {
+      rmSync2(target, { recursive: true, force: true });
+    } else {
+      rmSync2(target, { force: true });
+    }
+  }
+  const parentDir = join4(target, "..");
   try {
-    const { readdirSync: readdirSync3 } = __require("fs");
-    if (existsSync5(parentDir) && readdirSync3(parentDir).length === 0) {
+    if (existsSync5(parentDir) && readdirSync(parentDir).length === 0) {
       rmSync2(parentDir, { recursive: true });
     }
   } catch {
@@ -1883,6 +1937,7 @@ var claudeAdapter = {
   descriptor: descriptor2,
   detect: detect2,
   resolvePath: resolvePath2,
+  resolvePackageDir,
   transformContent: transformContent2,
   install: install2,
   uninstall: uninstall2,
@@ -2334,8 +2389,32 @@ function getAllAdapters() {
   return [...adapters.values()];
 }
 
+// src/lib/extract.ts
+import { unzipSync } from "fflate";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join12, dirname as dirname3, resolve as resolve2 } from "path";
+function extractPackage(zipBuffer, targetDir) {
+  const resolvedTarget = resolve2(targetDir);
+  const extracted = unzipSync(new Uint8Array(zipBuffer));
+  const writtenFiles = [];
+  for (const [path, data] of Object.entries(extracted)) {
+    if (path.endsWith("/")) continue;
+    if (path.includes("..") || path.startsWith("/") || path.startsWith("\\") || path.includes("\0")) {
+      continue;
+    }
+    const fullPath = resolve2(join12(targetDir, path));
+    if (!fullPath.startsWith(resolvedTarget + "/") && fullPath !== resolvedTarget) {
+      continue;
+    }
+    mkdirSync5(dirname3(fullPath), { recursive: true });
+    writeFileSync5(fullPath, Buffer.from(data));
+    writtenFiles.push(path);
+  }
+  return writtenFiles;
+}
+
 // src/lib/cache.ts
-var CACHE_DIR = join12(homedir8(), ".localskills", "cache");
+var CACHE_DIR = join13(homedir8(), ".localskills", "cache");
 function slugToDir(slug) {
   if (slug.includes("..") || slug.includes("\0")) {
     throw new Error("Invalid slug: contains forbidden characters");
@@ -2343,16 +2422,16 @@ function slugToDir(slug) {
   return slug.replace(/\//g, "--");
 }
 function getCacheDir(slug) {
-  const dir = resolve2(join12(CACHE_DIR, slugToDir(slug)));
-  if (!dir.startsWith(resolve2(CACHE_DIR) + "/") && dir !== resolve2(CACHE_DIR)) {
+  const dir = resolve3(join13(CACHE_DIR, slugToDir(slug)));
+  if (!dir.startsWith(resolve3(CACHE_DIR) + "/") && dir !== resolve3(CACHE_DIR)) {
     throw new Error("Invalid slug: path traversal detected");
   }
   return dir;
 }
 function store(slug, content, skill, version2) {
   const dir = getCacheDir(slug);
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync5(join12(dir, "raw.md"), content);
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync6(join13(dir, "raw.md"), content);
   const meta = {
     hash: skill.contentHash,
     version: version2,
@@ -2362,7 +2441,7 @@ function store(slug, content, skill, version2) {
     type: skill.type ?? "skill",
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync5(join12(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+  writeFileSync6(join13(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
   clearPlatformFiles(slug);
 }
 function getPlatformFile(slug, platform, skill) {
@@ -2373,25 +2452,25 @@ function getPlatformFile(slug, platform, skill) {
   const transformed = adapter.transformContent(raw, skill);
   if (platform === "claude") {
     if (skill.type === "rule") {
-      const claudeRuleDir = join12(dir, "claude-rule");
-      mkdirSync5(claudeRuleDir, { recursive: true });
-      const filePath3 = join12(claudeRuleDir, `${slug.replace(/\//g, "-")}.md`);
-      writeFileSync5(filePath3, transformed);
+      const claudeRuleDir = join13(dir, "claude-rule");
+      mkdirSync6(claudeRuleDir, { recursive: true });
+      const filePath3 = join13(claudeRuleDir, `${slug.replace(/\//g, "-")}.md`);
+      writeFileSync6(filePath3, transformed);
       return filePath3;
     }
-    const claudeDir = join12(dir, "claude");
-    mkdirSync5(claudeDir, { recursive: true });
-    const filePath2 = join12(claudeDir, "SKILL.md");
-    writeFileSync5(filePath2, transformed);
+    const claudeDir = join13(dir, "claude");
+    mkdirSync6(claudeDir, { recursive: true });
+    const filePath2 = join13(claudeDir, "SKILL.md");
+    writeFileSync6(filePath2, transformed);
     return filePath2;
   }
   const ext = adapter.descriptor.fileExtension;
-  const filePath = join12(dir, `${platform}${ext}`);
-  writeFileSync5(filePath, transformed);
+  const filePath = join13(dir, `${platform}${ext}`);
+  writeFileSync6(filePath, transformed);
   return filePath;
 }
 function getRawContent(slug) {
-  const filePath = join12(getCacheDir(slug), "raw.md");
+  const filePath = join13(getCacheDir(slug), "raw.md");
   if (!existsSync13(filePath)) return null;
   return readFileSync4(filePath, "utf-8");
 }
@@ -2401,11 +2480,18 @@ function purge(slug) {
     rmSync3(dir, { recursive: true, force: true });
   }
 }
+function getPackageDir(slug) {
+  return join13(getCacheDir(slug), "pkg");
+}
 function storePackage(slug, zipBuffer, manifest, skill, version2) {
   const dir = getCacheDir(slug);
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync5(join12(dir, "package.zip"), zipBuffer);
-  writeFileSync5(join12(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+  mkdirSync6(dir, { recursive: true });
+  const pkgDir = join13(dir, "pkg");
+  rmSync3(pkgDir, { recursive: true, force: true });
+  mkdirSync6(pkgDir, { recursive: true });
+  extractPackage(zipBuffer, pkgDir);
+  rmSync3(join13(dir, "package.zip"), { force: true });
+  writeFileSync6(join13(dir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
   const meta = {
     hash: skill.contentHash,
     version: version2,
@@ -2416,41 +2502,44 @@ function storePackage(slug, zipBuffer, manifest, skill, version2) {
     format: "package",
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync5(join12(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
+  writeFileSync6(join13(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n");
 }
 function clearPlatformFiles(slug) {
   const dir = getCacheDir(slug);
   if (!existsSync13(dir)) return;
-  const keep = /* @__PURE__ */ new Set(["raw.md", "meta.json", "package.zip", "manifest.json"]);
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+  const keep = /* @__PURE__ */ new Set(["raw.md", "meta.json", "manifest.json", "pkg"]);
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (!keep.has(entry.name)) {
-      rmSync3(join12(dir, entry.name), { recursive: true, force: true });
+      rmSync3(join13(dir, entry.name), { recursive: true, force: true });
     }
   }
 }
 
-// src/lib/extract.ts
-import { unzipSync } from "fflate";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join13, dirname as dirname3, resolve as resolve3 } from "path";
-function extractPackage(zipBuffer, targetDir) {
-  const resolvedTarget = resolve3(targetDir);
-  const extracted = unzipSync(new Uint8Array(zipBuffer));
-  const writtenFiles = [];
-  for (const [path, data] of Object.entries(extracted)) {
-    if (path.endsWith("/")) continue;
-    if (path.includes("..") || path.startsWith("/") || path.startsWith("\\") || path.includes("\0")) {
-      continue;
-    }
-    const fullPath = resolve3(join13(targetDir, path));
-    if (!fullPath.startsWith(resolvedTarget + "/") && fullPath !== resolvedTarget) {
-      continue;
-    }
-    mkdirSync6(dirname3(fullPath), { recursive: true });
-    writeFileSync6(fullPath, Buffer.from(data));
-    writtenFiles.push(path);
+// src/lib/package-target.ts
+import { lstatSync as lstatSync2, readdirSync as readdirSync3 } from "fs";
+import { basename, dirname as dirname4, join as join14 } from "path";
+import { homedir as homedir9 } from "os";
+function packageTargetConflict(targetDir, ownedByConfig) {
+  try {
+    lstatSync2(targetDir);
+  } catch {
+    return null;
   }
-  return writtenFiles;
+  if (ownedByConfig) return null;
+  if (isSymlinkInto(targetDir, join14(homedir9(), ".localskills", "cache"))) {
+    return null;
+  }
+  return `${targetDir} already exists and isn't managed by localskills \u2014 move or remove it first`;
+}
+function soleTrackedOccupant(targetDir, installedPath) {
+  if (dirname4(installedPath) !== targetDir) return false;
+  let entries;
+  try {
+    entries = readdirSync3(targetDir);
+  } catch {
+    return false;
+  }
+  return entries.length === 1 && entries[0] === basename(installedPath);
 }
 
 // src/lib/interactive.ts
@@ -2570,6 +2659,32 @@ function buildSkillRecord(cacheKey, skill, version2, resolvedSemver, requestedRa
     installations: existingInstallations ? [...existingInstallations, ...newInstallations] : newInstallations
   };
 }
+function reconcilePlatformInstalls(existing, slug, platformId, scope, projectDir, newPath, newFormat) {
+  const remaining = [];
+  const stale = [];
+  let ownedTarget = false;
+  for (const inst of existing ?? []) {
+    const sameTarget = inst.platform === platformId && inst.scope === scope && (inst.projectDir ?? null) === (projectDir ?? null);
+    if (!sameTarget) {
+      remaining.push(inst);
+      continue;
+    }
+    if (inst.path === newPath && (inst.format ?? "text") === newFormat) {
+      ownedTarget = true;
+      continue;
+    }
+    stale.push(inst);
+  }
+  return { remaining, stale, ownedTarget };
+}
+function removeStaleInstalls(stale, slug) {
+  for (const inst of stale) {
+    try {
+      getAdapter(inst.platform).uninstall(inst, slug);
+    } catch {
+    }
+  }
+}
 var installCommand = new Command2("install").description("Install a skill locally").argument("[slug]", "Skill slug (omit for interactive search)").option("-t, --target <targets...>", "Target platforms (cursor, claude, codex, ...)").option("-g, --global", "Install globally").option("-p, --project [dir]", "Install in project directory").option("--symlink", "Use symlink (default)").option("--copy", "Copy instead of symlink").action(
   async (slugArg, opts) => {
     const client = new ApiClient();
@@ -2652,11 +2767,20 @@ var installCommand = new Command2("install").description("Install a skill locall
       spinner.stop(`Fetched ${skill2.name} ${formatVersionLabel(resolvedSemver2, version3)} (package, ${manifest.files.length} files)`);
       const dlSpinner = bt2();
       dlSpinner.start("Downloading package...");
-      const zipBuffer = await client.fetchBinary(downloadUrl);
+      let zipBuffer;
+      try {
+        zipBuffer = await client.fetchBinary(downloadUrl);
+      } catch (err) {
+        dlSpinner.stop(`Download failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+        return;
+      }
       dlSpinner.stop(`Downloaded ${(zipBuffer.length / 1024).toFixed(1)} KB`);
       storePackage(cacheKey, zipBuffer, manifest, skill2, version3);
+      const pkgDir = getPackageDir(cacheKey);
       const installations2 = [];
       const results2 = [];
+      let existingInstallations2 = config.installed_skills[cacheKey]?.installations;
       for (const platformId of platforms) {
         const adapter = getAdapter(platformId);
         const desc = adapter.descriptor;
@@ -2668,19 +2792,55 @@ var installCommand = new Command2("install").description("Install a skill locall
           R2.warn(`${desc.name} does not support project \u2014 skipping.`);
           continue;
         }
-        const targetPath = adapter.resolvePath(cacheKey, scope, projectDir, skill2.type ?? "skill");
-        mkdirSync7(targetPath, { recursive: true });
-        const written = extractPackage(zipBuffer, targetPath);
+        if (!adapter.resolvePackageDir) {
+          R2.warn(`${desc.name} does not support multi-file (folder) skills \u2014 skipping.`);
+          continue;
+        }
+        const targetDir = adapter.resolvePackageDir(cacheKey, scope, projectDir, skill2.type ?? "skill");
+        const reconciled = reconcilePlatformInstalls(
+          existingInstallations2,
+          cacheKey,
+          platformId,
+          scope,
+          projectDir,
+          targetDir,
+          "package"
+        );
+        const owned = reconciled.ownedTarget || reconciled.stale.some((inst) => soleTrackedOccupant(targetDir, inst.path));
+        const conflict = packageTargetConflict(targetDir, owned);
+        if (conflict) {
+          R2.warn(`${desc.name} \u2014 ${conflict}. Skipping.`);
+          existingInstallations2 = [...reconciled.remaining, ...reconciled.stale];
+          continue;
+        }
+        removeStaleInstalls(reconciled.stale, cacheKey);
+        existingInstallations2 = reconciled.remaining;
+        const actualMethod = method === "copy" ? "copy" : "symlink";
+        if (actualMethod === "symlink") {
+          createSymlink(pkgDir, targetDir);
+        } else {
+          rmSync4(targetDir, { recursive: true, force: true });
+          mkdirSync7(dirname5(targetDir), { recursive: true });
+          cpSync(pkgDir, targetDir, { recursive: true });
+        }
         const installation = {
           platform: platformId,
           scope,
-          method: "copy",
-          path: targetPath,
+          method: actualMethod,
+          path: targetDir,
           projectDir,
-          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          format: "package"
         };
         installations2.push(installation);
-        results2.push(`${desc.name} \u2192 ${targetPath} (${written.length} files extracted)`);
+        const methodLabel = actualMethod === "symlink" ? "symlinked" : "copied";
+        results2.push(`${desc.name} \u2192 ${targetDir} (${methodLabel}, ${manifest.files.length} files)`);
+      }
+      if (installations2.length === 0) {
+        R2.error("No compatible targets for this folder skill.");
+        R2.info("Folder (package) skills currently install to Claude Code only.");
+        process.exit(1);
+        return;
       }
       config.installed_skills[cacheKey] = buildSkillRecord(
         cacheKey,
@@ -2688,7 +2848,7 @@ var installCommand = new Command2("install").description("Install a skill locall
         version3,
         resolvedSemver2,
         requestedRange,
-        config.installed_skills[cacheKey]?.installations,
+        existingInstallations2,
         installations2
       );
       saveConfig(config);
@@ -2704,6 +2864,7 @@ var installCommand = new Command2("install").description("Install a skill locall
     const contentType = skill.type ?? "skill";
     const installations = [];
     const results = [];
+    let existingInstallations = config.installed_skills[cacheKey]?.installations;
     for (const platformId of platforms) {
       const adapter = getAdapter(platformId);
       const desc = adapter.descriptor;
@@ -2716,6 +2877,18 @@ var installCommand = new Command2("install").description("Install a skill locall
         continue;
       }
       const actualMethod = adapter.defaultMethod(scope) === "section" ? "section" : method;
+      const newPath = adapter.resolvePath(cacheKey, scope, projectDir, contentType);
+      const reconciledText = reconcilePlatformInstalls(
+        existingInstallations,
+        cacheKey,
+        platformId,
+        scope,
+        projectDir,
+        newPath,
+        "text"
+      );
+      removeStaleInstalls(reconciledText.stale, cacheKey);
+      existingInstallations = reconciledText.remaining;
       const cachePath = getPlatformFile(cacheKey, platformId, skill);
       const transformed = adapter.transformContent(content, skill);
       const installedPath = adapter.install({
@@ -2733,7 +2906,8 @@ var installCommand = new Command2("install").description("Install a skill locall
         method: actualMethod,
         path: installedPath,
         projectDir,
-        installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        format: "text"
       };
       installations.push(installation);
       const methodLabel = actualMethod === "symlink" ? "symlinked" : actualMethod === "section" ? "section" : "copied";
@@ -2745,7 +2919,7 @@ var installCommand = new Command2("install").description("Install a skill locall
       version2,
       resolvedSemver,
       requestedRange,
-      config.installed_skills[cacheKey]?.installations,
+      existingInstallations,
       installations
     );
     saveConfig(config);
@@ -2861,8 +3035,21 @@ ${res.data.length} skill(s) found.`);
 });
 
 // src/commands/pull.ts
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync8, rmSync as rmSync5, cpSync as cpSync2, statSync as statSync2 } from "fs";
+import { dirname as dirname6 } from "path";
 import { Command as Command5 } from "commander";
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function installedAsPackage(inst) {
+  if (inst.format === "package") return true;
+  if (inst.format === "text") return false;
+  try {
+    return statSync2(inst.path).isDirectory();
+  } catch {
+    return false;
+  }
+}
 var pullCommand = new Command5("pull").description("Pull latest versions of all installed skills").argument("[slug]", "Pull a specific skill (omit for all)").action(async (slugArg) => {
   const config = loadConfig();
   const slugs = slugArg ? [slugArg] : Object.keys(config.installed_skills);
@@ -2898,53 +3085,129 @@ var pullCommand = new Command5("pull").description("Pull latest versions of all
       skipped++;
       continue;
     }
+    let allHandled = true;
     if (format === "package") {
       const { downloadUrl, manifest } = resData;
-      const zipBuffer = await client.fetchBinary(downloadUrl);
+      let zipBuffer;
+      try {
+        zipBuffer = await client.fetchBinary(downloadUrl);
+      } catch (err) {
+        spinner.stop(`${slug} \u2014 download failed: ${errMsg(err)}`);
+        continue;
+      }
       storePackage(slug, zipBuffer, manifest, skill, version2);
+      const pkgDir = getPackageDir(slug);
+      const kept = [];
       for (const installation of installed.installations) {
         const adapter = getAdapter(installation.platform);
-        const targetPath = adapter.resolvePath(slug, installation.scope, installation.projectDir, skill.type ?? "skill");
-        mkdirSync8(targetPath, { recursive: true });
-        extractPackage(zipBuffer, targetPath);
+        const wasPackage = installedAsPackage(installation);
+        if (!adapter.resolvePackageDir) {
+          R2.warn(
+            `${adapter.descriptor.name} can't hold a folder skill \u2014 keeping the existing install; it won't receive this update.`
+          );
+          kept.push(installation);
+          allHandled = false;
+          continue;
+        }
+        try {
+          const targetDir = adapter.resolvePackageDir(slug, installation.scope, installation.projectDir, skill.type ?? "skill");
+          const owned = wasPackage && installation.path === targetDir || !wasPackage && soleTrackedOccupant(targetDir, installation.path);
+          const conflict = packageTargetConflict(targetDir, owned);
+          if (conflict) {
+            R2.warn(
+              `${adapter.descriptor.name} \u2014 ${conflict}. Skipping; reinstall with \`localskills install ${slug}\`.`
+            );
+            kept.push(installation);
+            allHandled = false;
+            continue;
+          }
+          if (!wasPackage) {
+            adapter.uninstall(installation, slug);
+          }
+          const useMethod = installation.method === "copy" ? "copy" : "symlink";
+          if (useMethod === "symlink") {
+            createSymlink(pkgDir, targetDir);
+          } else {
+            rmSync5(targetDir, { recursive: true, force: true });
+            mkdirSync8(dirname6(targetDir), { recursive: true });
+            cpSync2(pkgDir, targetDir, { recursive: true });
+          }
+          kept.push({ ...installation, method: useMethod, path: targetDir, format: "package" });
+        } catch (err) {
+          R2.warn(`${adapter.descriptor.name} \u2014 failed to update: ${errMsg(err)}`);
+          kept.push(installation);
+          allHandled = false;
+        }
       }
+      installed.installations = kept;
     } else {
       const { content } = resData;
       store(slug, content, skill, version2);
       for (const installation of installed.installations) {
-        if (installation.method === "symlink") {
-          getPlatformFile(slug, installation.platform, skill);
-          continue;
-        }
         const adapter = getAdapter(installation.platform);
-        const transformed = adapter.transformContent(content, skill);
-        if (installation.method === "section") {
-          upsertSection(
-            installation.path,
-            slug,
-            `## ${slug}
+        try {
+          const transformed = adapter.transformContent(content, skill);
+          if (installedAsPackage(installation)) {
+            adapter.uninstall(installation, slug);
+            const method = installation.method === "section" ? "copy" : installation.method;
+            const cachePath = getPlatformFile(slug, installation.platform, skill);
+            const installedPath = adapter.install({
+              slug,
+              content: transformed,
+              scope: installation.scope,
+              method,
+              cachePath,
+              projectDir: installation.projectDir,
+              contentType: skill.type
+            });
+            installation.path = installedPath;
+            installation.method = method;
+            installation.format = "text";
+            continue;
+          }
+          if (installation.method === "symlink") {
+            getPlatformFile(slug, installation.platform, skill);
+            installation.format = "text";
+            continue;
+          }
+          if (installation.method === "section") {
+            upsertSection(
+              installation.path,
+              slug,
+              `## ${slug}
 
 ${transformed}`
-          );
-        } else {
-          const cachePath = getPlatformFile(slug, installation.platform, skill);
-          adapter.install({
-            slug,
-            content: transformed,
-            scope: installation.scope,
-            method: "copy",
-            cachePath,
-            projectDir: installation.projectDir
-          });
+            );
+          } else {
+            const cachePath = getPlatformFile(slug, installation.platform, skill);
+            adapter.install({
+              slug,
+              content: transformed,
+              scope: installation.scope,
+              method: "copy",
+              cachePath,
+              projectDir: installation.projectDir,
+              contentType: skill.type
+            });
+          }
+          installation.format = "text";
+        } catch (err) {
+          R2.warn(`${adapter.descriptor.name} \u2014 failed to update: ${errMsg(err)}`);
+          allHandled = false;
         }
       }
     }
-    installed.hash = skill.contentHash;
-    installed.version = version2;
-    installed.semver = resData.semver ?? null;
-    installed.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
-    updated++;
-    spinner.stop(`${slug} \u2014 updated to ${formatVersionLabel(res.data.semver, version2)}`);
+    if (allHandled) {
+      installed.hash = skill.contentHash;
+      installed.version = version2;
+      installed.semver = resData.semver ?? null;
+      installed.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
+      updated++;
+      spinner.stop(`${slug} \u2014 updated to ${formatVersionLabel(res.data.semver, version2)}`);
+    } else {
+      updated++;
+      spinner.stop(`${slug} \u2014 partially updated to ${formatVersionLabel(res.data.semver, version2)} (see warnings above)`);
+    }
   }
   saveConfig(config);
   Le(`Pull complete. ${updated} updated, ${skipped} up to date.`);
@@ -2952,44 +3215,43 @@ ${transformed}`
 
 // src/commands/publish.ts
 import { Command as Command6 } from "commander";
-import { readFileSync as readFileSync6, existsSync as existsSync15 } from "fs";
-import { resolve as resolve4, basename as basename2, extname as extname2 } from "path";
-import { homedir as homedir10 } from "os";
+import { readFileSync as readFileSync7, existsSync as existsSync15, statSync as statSync4 } from "fs";
+import { resolve as resolve4, basename as basename3, extname as extname2 } from "path";
+import { homedir as homedir11 } from "os";
 
 // src/lib/scanner.ts
-import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { join as join14, basename, extname } from "path";
-import { homedir as homedir9 } from "os";
-import { readlinkSync, lstatSync as lstatSync2 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join15, basename as basename2, extname, dirname as dirname7 } from "path";
+import { homedir as homedir10 } from "os";
 function scanForSkills(projectDir) {
-  const home = homedir9();
+  const home = homedir10();
   const cwd = projectDir || process.cwd();
   const results = [];
-  scanDirectory(join14(home, ".cursor", "rules"), ".mdc", "cursor", "global", results);
-  scanDirectory(join14(cwd, ".cursor", "rules"), ".mdc", "cursor", "project", results);
-  scanClaudeSkills(join14(home, ".claude", "skills"), "global", results);
-  scanClaudeSkills(join14(cwd, ".claude", "skills"), "project", results);
-  scanDirectory(join14(home, ".claude", "rules"), ".md", "claude", "global", results, "rule");
-  scanDirectory(join14(cwd, ".claude", "rules"), ".md", "claude", "project", results, "rule");
-  scanSingleFile(join14(home, ".codex", "AGENTS.md"), "codex", "global", results);
-  scanSingleFile(join14(cwd, "AGENTS.md"), "codex", "project", results);
+  scanDirectory(join15(home, ".cursor", "rules"), ".mdc", "cursor", "global", results);
+  scanDirectory(join15(cwd, ".cursor", "rules"), ".mdc", "cursor", "project", results);
+  scanClaudeSkills(join15(home, ".claude", "skills"), "global", results);
+  scanClaudeSkills(join15(cwd, ".claude", "skills"), "project", results);
+  scanDirectory(join15(home, ".claude", "rules"), ".md", "claude", "global", results, "rule");
+  scanDirectory(join15(cwd, ".claude", "rules"), ".md", "claude", "project", results, "rule");
+  scanSingleFile(join15(home, ".codex", "AGENTS.md"), "codex", "global", results);
+  scanSingleFile(join15(cwd, "AGENTS.md"), "codex", "project", results);
   scanSingleFile(
-    join14(home, ".codeium", "windsurf", "memories", "global_rules.md"),
+    join15(home, ".codeium", "windsurf", "memories", "global_rules.md"),
     "windsurf",
     "global",
     results
   );
-  scanDirectory(join14(cwd, ".windsurf", "rules"), ".md", "windsurf", "project", results);
-  scanDirectory(join14(cwd, ".clinerules"), ".md", "cline", "project", results);
+  scanDirectory(join15(cwd, ".windsurf", "rules"), ".md", "windsurf", "project", results);
+  scanDirectory(join15(cwd, ".clinerules"), ".md", "cline", "project", results);
   scanSingleFile(
-    join14(cwd, ".github", "copilot-instructions.md"),
+    join15(cwd, ".github", "copilot-instructions.md"),
     "copilot",
     "project",
     results
   );
-  scanDirectory(join14(home, ".config", "opencode", "rules"), ".md", "opencode", "global", results);
-  scanDirectory(join14(cwd, ".opencode", "rules"), ".md", "opencode", "project", results);
-  scanDirectory(join14(cwd, ".aider", "skills"), ".md", "aider", "project", results);
+  scanDirectory(join15(home, ".config", "opencode", "rules"), ".md", "opencode", "global", results);
+  scanDirectory(join15(cwd, ".opencode", "rules"), ".md", "opencode", "project", results);
+  scanDirectory(join15(cwd, ".aider", "skills"), ".md", "aider", "project", results);
   return results;
 }
 function filterTracked(detected, config) {
@@ -2999,35 +3261,32 @@ function filterTracked(detected, config) {
       trackedPaths.add(inst.path);
     }
   }
-  const cacheDir = join14(homedir9(), ".localskills", "cache");
+  const cacheDir = join15(homedir10(), ".localskills", "cache");
   return detected.filter((skill) => {
-    if (trackedPaths.has(skill.filePath)) return false;
-    try {
-      const stat = lstatSync2(skill.filePath);
-      if (stat.isSymbolicLink()) {
-        const target = readlinkSync(skill.filePath);
-        if (target.startsWith(cacheDir)) return false;
-      }
-    } catch {
+    const candidates = [skill.filePath, dirname7(skill.filePath)];
+    if (skill.dir) candidates.push(skill.dir);
+    for (const path of candidates) {
+      if (trackedPaths.has(path)) return false;
+      if (isSymlinkInto(path, cacheDir)) return false;
     }
     return true;
   });
 }
 function slugFromFilename(filename) {
-  return basename(filename, extname(filename));
+  return basename2(filename, extname(filename));
 }
 var nameFromSlug = titleFromSlug;
 function scanDirectory(dir, ext, platform, scope, results, contentType = "skill") {
   if (!existsSync14(dir)) return;
   let entries;
   try {
-    entries = readdirSync2(dir);
+    entries = readdirSync4(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.endsWith(ext)) continue;
-    const filePath = join14(dir, entry);
+    const filePath = join15(dir, entry);
     try {
       const raw = readFileSync5(filePath, "utf-8");
       const content = stripFrontmatter(raw).trim();
@@ -3035,6 +3294,7 @@ function scanDirectory(dir, ext, platform, scope, results, contentType = "skill"
       const slug = slugFromFilename(entry);
       results.push({
         filePath,
+        format: "text",
         platform,
         scope,
         suggestedName: nameFromSlug(slug),
@@ -3046,28 +3306,56 @@ function scanDirectory(dir, ext, platform, scope, results, contentType = "skill"
     }
   }
 }
+var SCAN_JUNK = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db", ".git", "node_modules", ".localskills"]);
+function dirHasFilesBesides(dir, excludeRootFile) {
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync4(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (SCAN_JUNK.has(entry.name)) continue;
+      if (entry.isDirectory()) {
+        stack.push(join15(current, entry.name));
+        continue;
+      }
+      if (current === dir && entry.name === excludeRootFile) continue;
+      return true;
+    }
+  }
+  return false;
+}
 function scanClaudeSkills(skillsDir, scope, results) {
   if (!existsSync14(skillsDir)) return;
   let entries;
   try {
-    entries = readdirSync2(skillsDir);
+    entries = readdirSync4(skillsDir);
   } catch {
     return;
   }
   for (const entry of entries) {
-    const skillFile = join14(skillsDir, entry, "SKILL.md");
+    const skillDir = join15(skillsDir, entry);
+    const skillFile = join15(skillDir, "SKILL.md");
     if (!existsSync14(skillFile)) continue;
     try {
       const raw = readFileSync5(skillFile, "utf-8");
       const content = stripFrontmatter(raw).trim();
-      if (!content) continue;
+      const isPackage = dirHasFilesBesides(skillDir, "SKILL.md");
+      if (!isPackage && !content) continue;
       results.push({
         filePath: skillFile,
+        ...isPackage ? { dir: skillDir } : {},
+        format: isPackage ? "package" : "text",
         platform: "claude",
         scope,
         suggestedName: nameFromSlug(entry),
         suggestedSlug: entry,
         content,
+        // for packages: SKILL.md body, used only for the hint/preview
         contentType: "skill"
       });
     } catch {
@@ -3094,6 +3382,7 @@ function scanSingleFile(filePath, platform, scope, results) {
       if (!content2) continue;
       results.push({
         filePath,
+        format: "text",
         platform,
         scope,
         suggestedName: nameFromSlug(slug2),
@@ -3109,6 +3398,7 @@ function scanSingleFile(filePath, platform, scope, results) {
   const slug = slugFromFilename(filePath);
   results.push({
     filePath,
+    format: "text",
     platform,
     scope,
     suggestedName: nameFromSlug(slug),
@@ -3118,8 +3408,177 @@ function scanSingleFile(filePath, platform, scope, results) {
   });
 }
 
+// src/lib/pack.ts
+import { readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { join as join16, relative as relative2, sep as sep2 } from "path";
+import { zipSync } from "fflate";
+var PackError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PackError";
+  }
+};
+function zipBlob(zip) {
+  return new Blob([new Uint8Array(zip)], { type: "application/zip" });
+}
+var SKIP = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  ".git",
+  "node_modules",
+  ".localskills",
+  "Thumbs.db"
+]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".tiff",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".wasm",
+  ".pyc",
+  ".class",
+  ".o",
+  ".obj",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".sqlite",
+  ".db"
+]);
+function getExtension(path) {
+  const dot = path.lastIndexOf(".");
+  return dot === -1 ? "" : path.substring(dot).toLowerCase();
+}
+function isBinaryByContent(data) {
+  const sample = data.subarray(0, 8192);
+  for (let i = 0; i < sample.length; i++) if (sample[i] === 0) return true;
+  return false;
+}
+function validatePath(path) {
+  if (path.startsWith("/") || path.startsWith("\\")) return false;
+  if (path.includes("..")) return false;
+  if (path.includes("\0")) return false;
+  if (path.includes("\\")) return false;
+  if (path === "__proto__") return false;
+  return true;
+}
+function walk(root, current, acc) {
+  for (const entry of readdirSync5(current, { withFileTypes: true })) {
+    if (SKIP.has(entry.name)) continue;
+    const abs = join16(current, entry.name);
+    const rel = relative2(root, abs).split(sep2).join("/");
+    let isFile = entry.isFile();
+    let size;
+    if (entry.isDirectory()) {
+      walk(root, abs, acc);
+      continue;
+    }
+    if (entry.isSymbolicLink()) {
+      let st3;
+      try {
+        st3 = statSync3(abs);
+      } catch {
+        acc.warnings.push(`Skipped broken symlink: ${rel}`);
+        continue;
+      }
+      if (st3.isDirectory()) {
+        acc.warnings.push(`Skipped symlinked directory: ${rel}/`);
+        continue;
+      }
+      isFile = st3.isFile();
+      size = st3.size;
+    }
+    if (!isFile) continue;
+    acc.count++;
+    if (acc.count > PACKAGE_MAX_FILE_COUNT) {
+      throw new PackError(
+        `Folder contains more than ${PACKAGE_MAX_FILE_COUNT} files`
+      );
+    }
+    size ??= statSync3(abs).size;
+    if (acc.bytes + size > PACKAGE_MAX_DECOMPRESSED_BYTES) {
+      throw new PackError(
+        `Folder exceeds ${PACKAGE_MAX_DECOMPRESSED_BYTES / 1024 / 1024} MB uncompressed limit`
+      );
+    }
+    const data = new Uint8Array(readFileSync6(abs));
+    acc.bytes += data.length;
+    if (acc.bytes > PACKAGE_MAX_DECOMPRESSED_BYTES) {
+      throw new PackError(
+        `Folder exceeds ${PACKAGE_MAX_DECOMPRESSED_BYTES / 1024 / 1024} MB uncompressed limit`
+      );
+    }
+    acc.files.set(rel, data);
+  }
+}
+function packFolder(dir, opts = {}) {
+  const requireSkillMd = opts.requireSkillMd ?? true;
+  const stat = statSync3(dir);
+  if (!stat.isDirectory()) throw new PackError(`Not a directory: ${dir}`);
+  const acc = { files: /* @__PURE__ */ new Map(), count: 0, bytes: 0, warnings: [] };
+  walk(dir, dir, acc);
+  const entries = acc.files;
+  if (entries.size === 0) throw new PackError("Folder contains no files");
+  if (requireSkillMd && !entries.has("SKILL.md")) {
+    throw new PackError(
+      "No SKILL.md at the folder root. A skill folder must contain a SKILL.md file."
+    );
+  }
+  let totalSize = 0;
+  const files = [];
+  for (const [path, data] of entries) {
+    if (!validatePath(path)) throw new PackError(`Invalid file path: ${path}`);
+    totalSize += data.length;
+    const binary = BINARY_EXTENSIONS.has(getExtension(path)) || isBinaryByContent(data);
+    const file = { path, size: data.length, isBinary: binary };
+    if (!binary && data.length > 0) {
+      const text = new TextDecoder("utf-8", { fatal: false }).decode(data);
+      file.preview = text.length > PACKAGE_PREVIEW_BYTES ? text.substring(0, PACKAGE_PREVIEW_BYTES) : text;
+    }
+    files.push(file);
+  }
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  const zipInput = /* @__PURE__ */ Object.create(null);
+  for (const [path, data] of entries) zipInput[path] = data;
+  const zip = Buffer.from(zipSync(zipInput));
+  if (zip.length > PACKAGE_MAX_COMPRESSED_BYTES) {
+    throw new PackError(
+      `Archive exceeds ${PACKAGE_MAX_COMPRESSED_BYTES / 1024 / 1024} MB compressed limit`
+    );
+  }
+  return {
+    zip,
+    manifest: { version: 1, totalSize, archiveSize: zip.length, files },
+    fileCount: files.length,
+    warnings: acc.warnings
+  };
+}
+
 // src/commands/publish.ts
-var publishCommand = new Command6("publish").description("Publish local skill files to localskills.sh").argument("[file]", "Path to a specific file to publish").option("-t, --team <id>", "Team ID to publish to").option("-n, --name <name>", "Skill name").option(
+var publishCommand = new Command6("publish").description("Publish local skills to localskills.sh").argument("[path]", "Path to a skill file, or a skill folder (uploaded as a package)").option("-t, --team <id>", "Team ID to publish to").option("-n, --name <name>", "Skill name").option(
   "--visibility <visibility>",
   "Visibility: public, private, or unlisted",
   "private"
@@ -3139,30 +3598,46 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
     if (fileArg) {
       const filePath = resolve4(fileArg);
       if (!existsSync15(filePath)) {
-        console.error(`File not found: ${filePath}`);
+        console.error(`Path not found: ${filePath}`);
         process.exit(1);
         return;
       }
-      const raw = readFileSync6(filePath, "utf-8");
+      if (statSync4(filePath).isDirectory()) {
+        const contentType2 = validateContentType(opts.type || "skill");
+        const visibility2 = validateVisibility(opts.visibility || "private");
+        const tenantId2 = await resolveTeam(teams, opts.team);
+        const skillName2 = opts.name || titleFromSlug(basename3(filePath));
+        const ok2 = await uploadPackage(client, {
+          name: skillName2,
+          dir: filePath,
+          tenantId: tenantId2,
+          visibility: visibility2,
+          type: contentType2
+        });
+        if (!ok2) process.exit(1);
+        return;
+      }
+      const raw = readFileSync7(filePath, "utf-8");
       const content = stripFrontmatter(raw).trim();
       if (!content) {
         console.error("File is empty after stripping frontmatter.");
         process.exit(1);
         return;
       }
-      const defaultSlug = basename2(filePath, extname2(filePath));
+      const defaultSlug = basename3(filePath, extname2(filePath));
       const defaultName = titleFromSlug(defaultSlug);
       const skillName = opts.name || defaultName;
       const contentType = validateContentType(opts.type || "skill");
       const visibility = validateVisibility(opts.visibility || "private");
       const tenantId = await resolveTeam(teams, opts.team);
-      await uploadSkill(client, {
+      const ok = await uploadSkill(client, {
         name: skillName,
         content,
         tenantId,
         visibility,
         type: contentType
       });
+      if (!ok) process.exit(1);
     } else {
       We("localskills publish");
       const spinner = bt2();
@@ -3187,6 +3662,7 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
         required: true
       }));
       const tenantId = await resolveTeam(teams, opts.team);
+      let failures = 0;
       for (const skill of skills) {
         R2.step(`Publishing ${skill.suggestedName}...`);
         const name = cancelGuard(await Ze({
@@ -3214,15 +3690,23 @@ var publishCommand = new Command6("publish").description("Publish local skill fi
           ],
           initialValue: skill.contentType
         }));
-        await uploadSkill(client, {
+        const ok = skill.format === "package" && skill.dir ? await uploadPackage(client, {
+          name,
+          dir: skill.dir,
+          tenantId,
+          visibility,
+          type: contentType
+        }) : await uploadSkill(client, {
           name,
           content: skill.content,
           tenantId,
           visibility,
           type: contentType
         });
+        if (!ok) failures++;
       }
-      Le("Done!");
+      Le(failures > 0 ? `Done, with ${failures} failure(s).` : "Done!");
+      if (failures > 0) process.exit(1);
     }
   }
 );
@@ -3259,10 +3743,37 @@ async function uploadSkill(client, params) {
   });
   if (!res.success || !res.data) {
     spinner.stop(`Failed: ${res.error || "Unknown error"}`);
-    return;
+    return false;
   }
   spinner.stop(`Published!`);
   R2.success(`\u2192 localskills.sh/s/${res.data.slug}`);
+  return true;
+}
+async function uploadPackage(client, params) {
+  const spinner = bt2();
+  let packed;
+  try {
+    packed = packFolder(params.dir, { requireSkillMd: params.type === "skill" });
+  } catch (e2) {
+    R2.error(e2 instanceof PackError ? e2.message : String(e2));
+    return false;
+  }
+  for (const w of packed.warnings) R2.warn(w);
+  spinner.start(`Uploading ${params.name} (${packed.fileCount} files)...`);
+  const form = new FormData();
+  form.append("name", params.name);
+  form.append("tenantId", params.tenantId);
+  form.append("visibility", params.visibility);
+  form.append("type", params.type);
+  form.append("file", zipBlob(packed.zip), "skill.zip");
+  const res = await client.postForm("/api/skills", form);
+  if (!res.success || !res.data) {
+    spinner.stop(`Failed: ${res.error || "Unknown error"}`);
+    return false;
+  }
+  spinner.stop(`Published! (${packed.fileCount} files)`);
+  R2.success(`\u2192 localskills.sh/s/${res.data.slug}`);
+  return true;
 }
 function validateContentType(value) {
   if (value === "skill" || value === "rule") {
@@ -3279,7 +3790,7 @@ function validateVisibility(value) {
   process.exit(1);
 }
 function shortenPath(filePath) {
-  const home = homedir10();
+  const home = homedir11();
   if (filePath.startsWith(home)) {
     return "~" + filePath.slice(home.length);
   }
@@ -3292,41 +3803,78 @@ function shortenPath(filePath) {
 
 // src/commands/push.ts
 import { Command as Command7 } from "commander";
-import { readFileSync as readFileSync7, existsSync as existsSync16 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync16, statSync as statSync5 } from "fs";
 import { resolve as resolve5 } from "path";
-var pushCommand = new Command7("push").description("Push a new version of an existing skill").argument("<file>", "Path to the skill file").requiredOption("-s, --skill <id>", "Skill ID or slug").option("--version <semver>", "Explicit semver (e.g., 1.1.0)").option("--patch", "Bump patch version").option("--minor", "Bump minor version").option("--major", "Bump major version").option("-m, --message <message>", "Version message").action(
+var pushCommand = new Command7("push").description("Push a new version of an existing skill").argument("<path>", "Path to the skill file, or a skill folder (uploaded as a package)").requiredOption("-s, --skill <id>", "Skill ID or slug").option("--version <semver>", "Explicit semver (e.g., 1.1.0)").option("--patch", "Bump patch version").option("--minor", "Bump minor version").option("--major", "Bump major version").option("-m, --message <message>", "Version message").action(
   async (fileArg, opts) => {
     const client = new ApiClient();
     requireAuth(client);
     const filePath = resolve5(fileArg);
     if (!existsSync16(filePath)) {
-      console.error(`File not found: ${filePath}`);
+      console.error(`Path not found: ${filePath}`);
       process.exit(1);
       return;
     }
-    const raw = readFileSync7(filePath, "utf-8");
-    const content = stripFrontmatter(raw).trim();
-    if (!content) {
-      console.error("File is empty after stripping frontmatter.");
+    const bumpFlags = [opts.patch, opts.minor, opts.major].filter(Boolean);
+    if (bumpFlags.length > 1) {
+      console.error("Specify only one of --patch, --minor, or --major");
       process.exit(1);
       return;
     }
-    const bumpFlags = [opts.patch, opts.minor, opts.major].filter(Boolean);
     if (opts.version && bumpFlags.length > 0) {
       console.error("Cannot specify both --version and --patch/--minor/--major");
       process.exit(1);
       return;
     }
+    if (opts.version && !isValidSemVer(opts.version)) {
+      console.error(`Invalid semver format: ${opts.version}. Expected X.Y.Z`);
+      process.exit(1);
+      return;
+    }
+    if (statSync5(filePath).isDirectory()) {
+      let packed;
+      try {
+        packed = packFolder(filePath, { requireSkillMd: false });
+      } catch (e2) {
+        console.error(e2 instanceof PackError ? e2.message : String(e2));
+        process.exit(1);
+        return;
+      }
+      for (const w of packed.warnings) R2.warn(w);
+      const form = new FormData();
+      form.append("file", zipBlob(packed.zip), "skill.zip");
+      if (opts.message) form.append("message", opts.message);
+      if (opts.version) form.append("semver", opts.version);
+      else if (opts.major) form.append("bump", "major");
+      else if (opts.minor) form.append("bump", "minor");
+      else if (opts.patch) form.append("bump", "patch");
+      const spinner2 = bt2();
+      spinner2.start(`Pushing new version (${packed.fileCount} files)...`);
+      const res2 = await client.postForm(
+        `/api/skills/${encodeURIComponent(opts.skill)}/versions`,
+        form
+      );
+      if (!res2.success || !res2.data) {
+        spinner2.stop(`Failed: ${res2.error || "Unknown error"}`);
+        process.exit(1);
+        return;
+      }
+      spinner2.stop(`Pushed ${formatVersionLabel(res2.data.semver, res2.data.version)}`);
+      Le("Done!");
+      return;
+    }
+    const raw = readFileSync8(filePath, "utf-8");
+    const content = stripFrontmatter(raw).trim();
+    if (!content) {
+      console.error("File is empty after stripping frontmatter.");
+      process.exit(1);
+      return;
+    }
     let body = {
       content,
       message: opts.message
     };
     if (opts.version) {
-      if (!isValidSemVer(opts.version)) {
-        console.error(`Invalid semver format: ${opts.version}. Expected X.Y.Z`);
-        process.exit(1);
-        return;
-      }
       body.semver = opts.version;
     } else if (opts.major) {
       body.bump = "major";
@@ -3354,30 +3902,49 @@ var pushCommand = new Command7("push").description("Push a new version of an exi
 
 // src/commands/share.ts
 import { Command as Command8 } from "commander";
-import { readFileSync as readFileSync8, existsSync as existsSync17 } from "fs";
-import { resolve as resolve6, basename as basename3, extname as extname3 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync17, statSync as statSync6 } from "fs";
+import { resolve as resolve6, basename as basename4, extname as extname3 } from "path";
 import { generateKeyPairSync } from "crypto";
-var shareCommand = new Command8("share").description("Share a skill anonymously (no login required)").argument("[file]", "Path to a specific file to share").option("-n, --name <name>", "Skill name").option("--type <type>", "Content type: skill or rule", "skill").action(async (fileArg, opts) => {
+var shareCommand = new Command8("share").description("Share a skill anonymously (no login required)").argument("[path]", "Path to a skill file, or a skill folder (uploaded as a package)").option("-n, --name <name>", "Skill name").option("--type <type>", "Content type: skill or rule", "skill").action(async (fileArg, opts) => {
   We("localskills share");
+  if (opts.type && opts.type !== "skill" && opts.type !== "rule") {
+    R2.error(`Invalid type: ${opts.type}. Use skill or rule.`);
+    process.exit(1);
+  }
   await ensureAnonymousIdentity();
   const client = new ApiClient();
   if (fileArg) {
     const filePath = resolve6(fileArg);
     if (!existsSync17(filePath)) {
-      R2.error(`File not found: ${filePath}`);
+      R2.error(`Path not found: ${filePath}`);
       process.exit(1);
     }
-    const raw = readFileSync8(filePath, "utf-8");
+    if (statSync6(filePath).isDirectory()) {
+      const contentType2 = opts.type === "rule" ? "rule" : "skill";
+      const skillName2 = opts.name || titleFromSlug(basename4(filePath));
+      const ok2 = await uploadAnonymousPackage(client, {
+        name: skillName2,
+        dir: filePath,
+        type: contentType2
+      });
+      Le(ok2 ? "Done!" : "Share failed.");
+      if (!ok2) process.exit(1);
+      return;
+    }
+    const raw = readFileSync9(filePath, "utf-8");
     const content = stripFrontmatter(raw).trim();
     if (!content) {
       R2.error("File is empty after stripping frontmatter.");
       process.exit(1);
     }
-    const defaultSlug = basename3(filePath, extname3(filePath));
+    const defaultSlug = basename4(filePath, extname3(filePath));
     const defaultName = titleFromSlug(defaultSlug);
     const skillName = opts.name || defaultName;
     const contentType = opts.type === "rule" ? "rule" : "skill";
-    await uploadAnonymousSkill(client, { name: skillName, content, type: contentType });
+    const ok = await uploadAnonymousSkill(client, { name: skillName, content, type: contentType });
+    Le(ok ? "Done!" : "Share failed.");
+    if (!ok) process.exit(1);
+    return;
   } else {
     const spinner = bt2();
     spinner.start("Scanning for skills...");
@@ -3411,13 +3978,18 @@ var shareCommand = new Command8("share").description("Share a skill anonymously
         }
       })
     );
-    await uploadAnonymousSkill(client, {
+    const ok = selected.format === "package" && selected.dir ? await uploadAnonymousPackage(client, {
+      name,
+      dir: selected.dir,
+      type: selected.contentType
+    }) : await uploadAnonymousSkill(client, {
       name,
       content: selected.content,
       type: selected.contentType
     });
+    Le(ok ? "Done!" : "Share failed.");
+    if (!ok) process.exit(1);
   }
-  Le("Done!");
 });
 async function ensureAnonymousIdentity() {
   const config = loadConfig();
@@ -3425,6 +3997,10 @@ async function ensureAnonymousIdentity() {
     const client = new ApiClient();
     const res2 = await client.get("/api/cli/auth");
     if (res2.success) return;
+    if (res2.networkError) {
+      R2.error(`Could not verify your login: ${res2.error}. Try again.`);
+      process.exit(1);
+    }
   }
   let keyPair = getAnonymousKey();
   if (!keyPair) {
@@ -3475,11 +4051,46 @@ async function uploadAnonymousSkill(client, params) {
   });
   if (!res.success || !res.data) {
     s.stop(`Failed: ${res.error || "Unknown error"}`);
-    return;
+    return false;
+  }
+  s.stop("Shared!");
+  R2.success(`URL:     https://localskills.sh/s/${res.data.publicId}`);
+  R2.info(`Install: localskills install ${res.data.publicId}`);
+  return true;
+}
+async function uploadAnonymousPackage(client, params) {
+  const s = bt2();
+  let packed;
+  try {
+    packed = packFolder(params.dir, { requireSkillMd: params.type === "skill" });
+  } catch (e2) {
+    R2.error(e2 instanceof PackError ? e2.message : String(e2));
+    return false;
+  }
+  for (const w of packed.warnings) R2.warn(w);
+  s.start(`Sharing "${params.name}" (${packed.fileCount} files)...`);
+  const teamsRes = await client.get("/api/tenants");
+  if (!teamsRes.success || !teamsRes.data || teamsRes.data.length === 0) {
+    s.stop("Failed to find your team. Try running `localskills share` again.");
+    process.exit(1);
+    return false;
+  }
+  const tenantId = teamsRes.data[0].id;
+  const form = new FormData();
+  form.append("name", params.name);
+  form.append("tenantId", tenantId);
+  form.append("visibility", "unlisted");
+  form.append("type", params.type);
+  form.append("file", zipBlob(packed.zip), "skill.zip");
+  const res = await client.postForm("/api/skills", form);
+  if (!res.success || !res.data) {
+    s.stop(`Failed: ${res.error || "Unknown error"}`);
+    return false;
   }
   s.stop("Shared!");
   R2.success(`URL:     https://localskills.sh/s/${res.data.publicId}`);
   R2.info(`Install: localskills install ${res.data.publicId}`);
+  return true;
 }
 
 // src/commands/profile.ts