shelfware 0.0.1 → 0.1.0

package/.output/server/chunks/_/catalog.mjs

@@ -0,0 +1,1115 @@
+import nodeCrypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { f as fail } from './api-handler.mjs';
+import { parse } from 'yaml';
+
+const SEVERITY_ORDER = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+const AUDIT_SKIP_WALK = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".cache",
+  "upstream",
+  "__pycache__",
+  ".venv",
+  "venv"
+]);
+const COMPANION_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".py",
+  ".js",
+  ".mjs",
+  ".cjs"
+]);
+const MAX_FILE_BYTES = 256e3;
+const MAX_TREE_BYTES = 512e3;
+const MAX_DEPTH = 4;
+const MAX_FILES = 12;
+const SHELL_FENCE_LANGUAGES = /* @__PURE__ */ new Set([
+  "",
+  "sh",
+  "shell",
+  "bash",
+  "zsh",
+  "fish",
+  "console",
+  "terminal"
+]);
+const DENYLIST_PATTERN = /(?:\bdo\s+not\b|\bdon't\b|\bnever\b|\bmust\s+not\b|\bavoid\b|\bforbidden\b|\bdenylist\b|\bblocklist\b)/i;
+const SHELLISH_LINE = /^(?:[-*+]\s+)?(?:[$>]\s*)?(?:sudo\s+)?(?:curl|wget|rm|git|bash|sh|zsh|fish|python(?:3)?|node|npm|npx|pnpm|yarn|eval|exec)\b/i;
+const IMPERATIVE_LINE = /^(?:[-*+]\s+)?(?:read|open|copy|upload|download|delete|remove|write|modify|send|execute|run)\b/i;
+const PROMPT_COMMAND = /^(?:[-*+]\s+)?(?:ignore|disregard)\b/i;
+const AUDIT_RULES = [
+  {
+    severity: "critical",
+    rule: "shell.remote-pipe",
+    pattern: /(?:curl|wget)\b[^\n|]{0,500}\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b/gi,
+    message: "Downloads are piped directly to a shell"
+  },
+  {
+    severity: "high",
+    rule: "filesystem.broad-delete",
+    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+(?:\/|~|\$HOME)(?:\s|$)/gi,
+    message: "Command may recursively delete a broad filesystem root"
+  },
+  {
+    severity: "high",
+    rule: "credentials.sensitive-path",
+    pattern: /(?:\.ssh\/(?:id_|config)|\.aws\/credentials|\.config\/gcloud|login\.keychain)/gi,
+    message: "References a sensitive credential location"
+  },
+  {
+    severity: "high",
+    rule: "execution.obfuscated",
+    pattern: /(?:eval|exec)\s*\([^\n]{0,200}(?:base64|b64decode)/gi,
+    message: "Executes obfuscated or decoded content"
+  },
+  {
+    severity: "medium",
+    rule: "prompt.override",
+    pattern: /(?:ignore|disregard)\s+(?:all\s+)?(?:previous|prior|system)\s+instructions/gi,
+    message: "Contains an instruction-override phrase"
+  },
+  {
+    severity: "medium",
+    rule: "git.global-config",
+    pattern: /git\s+config\s+--global/gi,
+    message: "Modifies global Git configuration"
+  },
+  {
+    severity: "low",
+    rule: "network.download",
+    pattern: /\b(?:curl|wget)\b/gi,
+    message: "Uses a network download command"
+  }
+];
+const SUBSUMED = {
+  "network.download": /* @__PURE__ */ new Set(["shell.remote-pipe"])
+};
+
+function maxSeverity(values) {
+  let best = "none";
+  for (const value of values) {
+    if (SEVERITY_ORDER[value] > SEVERITY_ORDER[best]) best = value;
+  }
+  return best;
+}
+function isDocument(rel) {
+  const ext = path.extname(rel).toLowerCase();
+  if (ext === ".md" || ext === ".txt" || ext === ".rst") return true;
+  return /(^|\/)skill\.md$/i.test(rel.replace(/\\/g, "/"));
+}
+function newlineStarts(content) {
+  const starts = [0];
+  for (let i = 0; i < content.length; i += 1) {
+    if (content.charCodeAt(i) === 10) starts.push(i + 1);
+  }
+  return starts;
+}
+function lineNumberAt(starts, index) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (starts[mid] <= index) lo = mid + 1;
+    else hi = mid - 1;
+  }
+  return hi + 1;
+}
+function fenceLanguage(line) {
+  const match = line.match(/^\s*```\s*([\w+-]*)/);
+  return match ? match[1].toLowerCase() : null;
+}
+function lineContext(rel, lines, lineIndex, rule, inShellFence) {
+  const line = lines[lineIndex] || "";
+  if (DENYLIST_PATTERN.test(line)) return "denylist";
+  const previous = [...lines.slice(Math.max(0, lineIndex - 4), lineIndex)].reverse().find((item) => item.trim());
+  if (previous && DENYLIST_PATTERN.test(previous) && (previous.trim().endsWith(":") || previous.trim().startsWith("#"))) {
+    return "denylist";
+  }
+  const stripped = line.trim();
+  if (isDocument(rel)) {
+    if (inShellFence) return "command_invocation";
+    if (SHELLISH_LINE.test(stripped) || IMPERATIVE_LINE.test(stripped)) return "command_invocation";
+    if (rule === "prompt.override" && PROMPT_COMMAND.test(stripped)) return "command_invocation";
+    return "documentation";
+  }
+  if (stripped.startsWith("#") || stripped.startsWith("//") || stripped.startsWith("*") || stripped.startsWith("/*")) {
+    return "documentation";
+  }
+  return "command_invocation";
+}
+function collectFromText(rel, content, findings) {
+  const lines = content.split(/\r?\n/);
+  let starts = null;
+  const fence = lines.map(() => false);
+  let inFence = false;
+  let language = "";
+  for (let i = 0; i < lines.length; i += 1) {
+    const lang = fenceLanguage(lines[i]);
+    if (lang != null) {
+      if (inFence) {
+        inFence = false;
+        language = "";
+      } else {
+        inFence = true;
+        language = lang;
+      }
+    }
+    fence[i] = inFence && SHELL_FENCE_LANGUAGES.has(language);
+  }
+  for (const spec of AUDIT_RULES) {
+    spec.pattern.lastIndex = 0;
+    let match;
+    while (match = spec.pattern.exec(content)) {
+      if (!starts) starts = newlineStarts(content);
+      const line = lineNumberAt(starts, match.index);
+      const lineIndex = Math.max(0, line - 1);
+      const context = lineContext(rel, lines, lineIndex, spec.rule, fence[lineIndex]);
+      if (context !== "command_invocation") continue;
+      if (findings.some((item) => item.file === rel && item.line === line && item.rule === spec.rule)) continue;
+      const subsumedBy = SUBSUMED[spec.rule];
+      if (subsumedBy && findings.some((item) => item.file === rel && item.line === line && subsumedBy.has(item.rule))) continue;
+      findings.push({ severity: spec.severity, rule: spec.rule, message: spec.message, file: rel, line });
+    }
+  }
+}
+function listTextFiles(root) {
+  const files = [];
+  const walk = (current, rel, depth) => {
+    if (depth > MAX_DEPTH || files.length >= MAX_FILES) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (AUDIT_SKIP_WALK.has(entry.name)) continue;
+      const abs = path.join(current, entry.name);
+      const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
+      let listed;
+      try {
+        listed = fs.lstatSync(abs);
+      } catch {
+        continue;
+      }
+      if (listed.isSymbolicLink()) continue;
+      if (listed.isDirectory()) {
+        walk(abs, nextRel, depth + 1);
+        continue;
+      }
+      if (!listed.isFile()) continue;
+      const ext = path.extname(entry.name).toLowerCase();
+      if (!COMPANION_EXTENSIONS.has(ext)) continue;
+      files.push({ abs, rel: nextRel, size: listed.size });
+    }
+  };
+  walk(root, "", 0);
+  return files;
+}
+function resolveWalkRoot(root) {
+  try {
+    const listed = fs.lstatSync(root);
+    if (listed.isSymbolicLink()) return fs.realpathSync(root);
+  } catch {
+  }
+  return path.resolve(root);
+}
+function auditSkill(input) {
+  const findings = [];
+  const skillRel = path.basename(input.skillFile);
+  if (typeof input.text === "string" && input.text) {
+    collectFromText(skillRel, input.text, findings);
+  }
+  if (!input.fileOnly) {
+    const start = resolveWalkRoot(input.root);
+    const already = path.resolve(input.skillFile);
+    let treeBytes = Buffer.byteLength(input.text || "", "utf8");
+    for (const file of listTextFiles(start)) {
+      if (path.resolve(file.abs) === already) continue;
+      if (file.size > MAX_FILE_BYTES) continue;
+      if (treeBytes + file.size > MAX_TREE_BYTES) break;
+      let content = "";
+      try {
+        content = fs.readFileSync(file.abs, "utf8");
+      } catch {
+        continue;
+      }
+      treeBytes += Buffer.byteLength(content, "utf8");
+      collectFromText(file.rel.replace(/\\/g, "/"), content, findings);
+    }
+  }
+  const hasPipe = findings.some((item) => item.rule === "shell.remote-pipe");
+  const visible = hasPipe ? findings.filter((item) => item.rule !== "network.download") : findings;
+  return {
+    severity: maxSeverity(visible.map((item) => item.severity)),
+    findings: visible
+  };
+}
+
+const FRONTMATTER_PARSE_ERROR = "YAML frontmatter could not be parsed";
+function parseFrontmatter(text) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---")) return { data: {}, content: normalized, raw: "" };
+  const end = normalized.indexOf("\n---", 3);
+  if (end === -1) return { data: {}, content: normalized, raw: "" };
+  const raw = normalized.slice(3, end).replace(/^\n/, "");
+  let data = {};
+  try {
+    const parsed = parse(raw, { logLevel: "error" });
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      data = parsed;
+    }
+  } catch {
+    data = { _parseError: FRONTMATTER_PARSE_ERROR };
+  }
+  const content = normalized.slice(end + 4).replace(/^\n\n?/, "");
+  return { data, content, raw };
+}
+function stringField(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : "";
+}
+
+const STANDING_ORDER = /\b(?:must\s+always\s+apply|always\s+apply|on\s+every\s+(?:request|turn|message|prompt)|before\s+every\s+(?:request|turn|message|prompt)|hooked\s+into\s+every|injected\s+at\s+session\s+start)\b/gi;
+const VERBAL_NEGATION = /\b(?:do\s+not|don't|does\s+not|doesn't|did\s+not|didn't|can\s+not|can't|cannot|never)\b/gi;
+function pathExists$1(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+function isTruthy(value) {
+  return value === true || value === "true" || value === "yes";
+}
+function isFalsy(value) {
+  return value === false || value === "false" || value === "no";
+}
+function hooksAt(dir) {
+  const nested = path.join(dir, "hooks", "hooks.json");
+  if (pathExists$1(nested)) return nested;
+  const flat = path.join(dir, "hooks.json");
+  if (pathExists$1(flat)) return flat;
+  return "";
+}
+function findSkillHooks(skillDir, { fileOnly = false } = {}) {
+  if (fileOnly) return "";
+  return hooksAt(skillDir);
+}
+function lastClauseCut(before) {
+  let cut = Math.max(before.lastIndexOf("."), before.lastIndexOf("!"), before.lastIndexOf("?"), before.lastIndexOf(";"));
+  const coord = /(?:,\s*)?\b(?:but|yet)\b|,\s*\b(?:and|or)\b/gi;
+  for (const match of before.matchAll(coord)) {
+    cut = Math.max(cut, match.index + match[0].length - 1);
+  }
+  return cut;
+}
+function clauseBefore(text, index) {
+  const before = text.slice(0, index);
+  return before.slice(lastClauseCut(before) + 1);
+}
+function negationApplies(clause) {
+  const re = new RegExp(VERBAL_NEGATION.source, "gi");
+  let last = null;
+  for (const match of clause.matchAll(re)) last = match;
+  if (!last || last.index === void 0) return false;
+  const rest = clause.slice(last.index + last[0].length).trim();
+  const words = rest ? rest.split(/\s+/).filter(Boolean) : [];
+  return words.length <= 5;
+}
+function hasStandingOrder(text) {
+  if (!text) return false;
+  const re = new RegExp(STANDING_ORDER.source, "gi");
+  for (const match of text.matchAll(re)) {
+    if (match.index !== void 0 && !negationApplies(clauseBefore(text, match.index))) return true;
+  }
+  return false;
+}
+function metadataOf(frontmatter) {
+  const meta = frontmatter.metadata;
+  return meta && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
+}
+function skillInvocation({ skillDir, fileOnly = false, frontmatter = {}, description = "" }) {
+  var _a;
+  const hookPath = findSkillHooks(skillDir, { fileOnly });
+  if (hookPath) {
+    return { invocation: "hook", invocationEvidence: `hooks.json at ${hookPath}` };
+  }
+  const meta = metadataOf(frontmatter);
+  if (isTruthy(frontmatter.sessionStart) || isTruthy(meta.sessionStart) || isTruthy(frontmatter.alwaysApply) || isTruthy(meta.alwaysApply)) {
+    const key = isTruthy(frontmatter.sessionStart) || isTruthy(meta.sessionStart) ? "sessionStart" : "alwaysApply";
+    return { invocation: "hook", invocationEvidence: `frontmatter ${key}` };
+  }
+  const blurb = description || (typeof frontmatter.description === "string" ? frontmatter.description : "");
+  if (hasStandingOrder(blurb)) {
+    return { invocation: "hook", invocationEvidence: "description standing order" };
+  }
+  if (isTruthy(frontmatter["disable-model-invocation"])) {
+    const userInvokable = (_a = frontmatter["user-invokable"]) != null ? _a : meta["user-invokable"];
+    if (isFalsy(userInvokable)) {
+      return { invocation: "off", invocationEvidence: "frontmatter disable-model-invocation and user-invokable false" };
+    }
+    return { invocation: "user", invocationEvidence: "frontmatter disable-model-invocation" };
+  }
+  return { invocation: "model", invocationEvidence: "default: the model may call this" };
+}
+
+function createOriginContext(home) {
+  return { home: path.resolve(home), cache: /* @__PURE__ */ new Map() };
+}
+const PLUGIN_JSON = [
+  ["plugin.json"],
+  [".cursor-plugin", "plugin.json"],
+  [".claude-plugin", "plugin.json"],
+  [".plugin", "plugin.json"]
+];
+function githubFromString(raw) {
+  if (!raw) return null;
+  const text = String(raw).trim().replace(/^["']|["']$/g, "");
+  const match = text.match(/(?:https?:\/\/|git@|ssh:\/\/git@)github\.com[:/]+([^\s#?]+)/i);
+  if (match) {
+    const parts = match[1].replace(/\.git$/i, "").split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      const spec = `${parts[0]}/${parts[1]}`;
+      return { kind: "github", label: spec, url: `https://github.com/${spec}` };
+    }
+  }
+  if (/^[\w.-]+\/[\w.-]+$/.test(text)) {
+    return { kind: "github", label: text, url: `https://github.com/${text}` };
+  }
+  return null;
+}
+function originFromText(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const github = githubFromString(raw);
+  if (github) return github;
+  const text = raw.trim().replace(/^["']|["']$/g, "");
+  if (!/^https?:\/\//i.test(text)) return null;
+  try {
+    const parsed = new URL(text);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+    parsed.username = "";
+    parsed.password = "";
+    const label = `${parsed.host}${parsed.pathname}`.replace(/\/+$/, "");
+    return { kind: "url", label, url: parsed.href };
+  } catch {
+    return null;
+  }
+}
+function originFromValue(value) {
+  if (typeof value === "string") return originFromText(value);
+  if (value && typeof value === "object" && typeof value.url === "string") {
+    return originFromText(value.url);
+  }
+  return null;
+}
+function withOrigin(origin, via, certainty) {
+  if (!origin) return null;
+  return { ...origin, via, certainty };
+}
+function originFromFrontmatter(data) {
+  const rawMeta = data.metadata;
+  const meta = rawMeta && typeof rawMeta === "object" && !Array.isArray(rawMeta) ? rawMeta : {};
+  for (const key of ["source", "repository"]) {
+    const found = originFromValue(data[key]) || originFromValue(meta[key]);
+    if (found) return withOrigin(found, "frontmatter", "attested");
+  }
+  for (const key of ["homepage", "url"]) {
+    const found = originFromValue(data[key]) || originFromValue(meta[key]);
+    if ((found == null ? void 0 : found.kind) === "github") return withOrigin(found, "frontmatter", "attested");
+  }
+  return null;
+}
+function originFromPath(p) {
+  const norm = p.replace(/\\/g, "/");
+  const market = norm.match(/\/marketplaces\/github\.com\/([^/]+)\/([^/]+)/);
+  if (market) {
+    return withOrigin(
+      { kind: "github", label: `${market[1]}/${market[2]}`, url: `https://github.com/${market[1]}/${market[2]}` },
+      "path",
+      "attested"
+    );
+  }
+  const nested = norm.match(/\/github\.com\/([^/]+)\/([^/]+)/);
+  if (nested && nested[1] !== "www") {
+    return withOrigin(
+      { kind: "github", label: `${nested[1]}/${nested[2]}`, url: `https://github.com/${nested[1]}/${nested[2]}` },
+      "path",
+      "attested"
+    );
+  }
+  return null;
+}
+function originFromPluginFile(file) {
+  try {
+    const st = fs.statSync(file, { throwIfNoEntry: false });
+    if (!st || !st.isFile()) return null;
+    const data = JSON.parse(fs.readFileSync(file, "utf8"));
+    const repo = originFromValue(data.repository);
+    if (repo) return repo;
+    const home = originFromText(data.homepage);
+    return (home == null ? void 0 : home.kind) === "github" ? home : null;
+  } catch {
+    return null;
+  }
+}
+function originFromGitDir(dir) {
+  const gitPath = path.join(dir, ".git");
+  try {
+    const listed = fs.lstatSync(gitPath, { throwIfNoEntry: false });
+    if (!listed) return null;
+    let configPath = "";
+    if (listed.isFile()) {
+      const text = fs.readFileSync(gitPath, "utf8");
+      const marker = text.match(/gitdir:\s*(.+)/i);
+      if (!marker) return null;
+      let gitdir = marker[1].trim();
+      if (!path.isAbsolute(gitdir)) gitdir = path.resolve(dir, gitdir);
+      configPath = path.join(gitdir, "config");
+    } else if (listed.isDirectory()) {
+      configPath = path.join(gitPath, "config");
+    } else {
+      return null;
+    }
+    const config = fs.readFileSync(configPath, "utf8");
+    const url = config.match(/\[remote "origin"\][\s\S]*?url\s*=\s*(\S+)/);
+    return url ? originFromText(url[1].replace(/^["']|["']$/g, "")) : null;
+  } catch {
+    return null;
+  }
+}
+function originStartDir(start) {
+  const resolved = path.resolve(start);
+  try {
+    const listed = fs.lstatSync(resolved);
+    if (listed.isSymbolicLink()) {
+      try {
+        if (fs.statSync(resolved).isFile()) return path.dirname(resolved);
+      } catch {
+        return path.dirname(resolved);
+      }
+    }
+    if (listed.isFile()) return path.dirname(resolved);
+  } catch {
+  }
+  return resolved;
+}
+function fromCachedOrigin(hit, startDir) {
+  if (!hit) return null;
+  const here = path.resolve(hit.at) === path.resolve(startDir);
+  return withOrigin(hit.origin, hit.via, here ? "attested" : "inferred");
+}
+function originFromAncestors(start, ctx) {
+  var _a;
+  const chain = [];
+  let current = originStartDir(start);
+  const startDir = current;
+  for (let i = 0; i < 14; i += 1) {
+    if (ctx.cache.has(current)) {
+      const hit = (_a = ctx.cache.get(current)) != null ? _a : null;
+      for (const dir of chain) ctx.cache.set(dir, hit);
+      return fromCachedOrigin(hit, startDir);
+    }
+    chain.push(current);
+    for (const parts of PLUGIN_JSON) {
+      const found = originFromPluginFile(path.join(current, ...parts));
+      if (found) {
+        const packed = { origin: found, via: "plugin", at: current };
+        for (const dir of chain) ctx.cache.set(dir, packed);
+        return fromCachedOrigin(packed, startDir);
+      }
+    }
+    const git = originFromGitDir(current);
+    if (git) {
+      const packed = { origin: git, via: "git", at: current };
+      for (const dir of chain) ctx.cache.set(dir, packed);
+      return fromCachedOrigin(packed, startDir);
+    }
+    const parent = path.dirname(current);
+    if (parent === current || parent === ctx.home) break;
+    current = parent;
+  }
+  for (const dir of chain) ctx.cache.set(dir, null);
+  return null;
+}
+function inferOrigin(dir, data, linkTarget, ctx) {
+  const yaml = originFromFrontmatter(data);
+  if (yaml) return yaml;
+  const fromHere = originFromPath(dir);
+  if (fromHere) return fromHere;
+  if (linkTarget) {
+    const resolved = path.isAbsolute(linkTarget) ? path.resolve(linkTarget) : path.resolve(path.dirname(dir), linkTarget);
+    const fromLink = originFromPath(resolved) || originFromAncestors(resolved, ctx);
+    if (fromLink) return fromLink;
+  }
+  return originFromAncestors(dir, ctx);
+}
+
+function homeOf(opts) {
+  var _a;
+  return realPath(path.resolve((_a = opts == null ? void 0 : opts.home) != null ? _a : os.homedir()));
+}
+function quarantineRoot(opts) {
+  return path.join(homeOf(opts), ".skill-cabinet", "quarantine");
+}
+const SKIP_HOME_DOTDIRS = /* @__PURE__ */ new Set([
+  ".cache",
+  ".local",
+  ".npm",
+  ".nvm",
+  ".rustup",
+  ".cargo",
+  ".docker",
+  ".mozilla",
+  ".config",
+  ".steam",
+  ".var",
+  ".wine",
+  ".thumbnails",
+  ".Trash",
+  ".android",
+  ".gradle",
+  ".java",
+  ".skill-cabinet"
+]);
+const SKIP_WALK = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".cache", "upstream"]);
+function pathExists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function realPath(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+function contained(child, parent) {
+  const c = path.resolve(child);
+  const p = path.resolve(parent);
+  return c === p || c.startsWith(p + path.sep);
+}
+function idFor(absPath) {
+  return nodeCrypto.createHash("sha1").update(absPath).digest("hex").slice(0, 16);
+}
+const NAMED_SKILL_FILES = /* @__PURE__ */ new Set(["skill.md", "SKILL.md"]);
+const IGNORE_LOOSE_MD = /* @__PURE__ */ new Set(["readme.md", "changelog.md", "license.md", "licence.md"]);
+function isSkillFileName(name) {
+  if (NAMED_SKILL_FILES.has(name)) return true;
+  if (!/\.md$/i.test(name)) return false;
+  return !IGNORE_LOOSE_MD.has(name.toLowerCase());
+}
+function findSkillFile(dir) {
+  for (const name of ["SKILL.md", "skill.md"]) {
+    const p = path.join(dir, name);
+    if (pathExists(p) && !isDir(p)) return p;
+  }
+  return null;
+}
+function readLinkTarget(p) {
+  try {
+    return fs.readlinkSync(p);
+  } catch {
+    return "";
+  }
+}
+function describeInstall(p) {
+  let link = false;
+  let file = false;
+  let linkTarget = "";
+  let dev = 0;
+  let ino = 0;
+  try {
+    const listed = fs.lstatSync(p);
+    link = listed.isSymbolicLink();
+    if (link) {
+      linkTarget = readLinkTarget(p);
+      try {
+        const followed = fs.statSync(p);
+        file = followed.isFile();
+        dev = followed.dev;
+        ino = followed.ino;
+      } catch {
+        file = false;
+      }
+    } else {
+      file = listed.isFile();
+      dev = listed.dev;
+      ino = listed.ino;
+    }
+  } catch {
+  }
+  return { link, file, linkTarget, dev, ino };
+}
+function readDirents(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function discoverRoots(opts) {
+  const home = homeOf(opts);
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (scopeId, scopeLabel, root, kind, recursive = false, deep = false) => {
+    if (!pathExists(root) || !isDir(root)) return;
+    const resolved = realPath(root);
+    if (seen.has(resolved)) return;
+    seen.add(resolved);
+    roots.push({ scopeId, scopeLabel, root: resolved, kind, recursive, deep });
+  };
+  for (const entry of readDirents(home)) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    if (!entry.name.startsWith(".")) continue;
+    if (SKIP_HOME_DOTDIRS.has(entry.name)) continue;
+    const base = path.join(home, entry.name);
+    const scopeId = entry.name.slice(1);
+    for (const folder of ["skills", "skill"]) {
+      add(scopeId, entry.name, path.join(base, folder), "user", false);
+    }
+    if (entry.name === ".cursor") {
+      add("cursor-builtin", ".cursor/skills-cursor", path.join(base, "skills-cursor"), "builtin", false);
+      add("cursor-plugins", ".cursor/plugins", path.join(base, "plugins"), "plugin", true);
+    }
+  }
+  add("gemini", ".gemini/antigravity", path.join(home, ".gemini/antigravity/skills"), "user", false);
+  add("gemini", ".gemini/antigravity (global)", path.join(home, ".gemini/antigravity/global_skills"), "user", false);
+  const hermesProfiles = path.join(home, ".hermes", "profiles");
+  for (const entry of readDirents(hermesProfiles)) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    if (entry.name.startsWith(".")) continue;
+    add(`hermes-profile:${entry.name}`, `Hermes profile \xB7 ${entry.name}`, path.join(hermesProfiles, entry.name, "skills"), "user", false, true);
+  }
+  const quarantine = quarantineRoot(opts);
+  for (const entry of readDirents(quarantine)) {
+    if (!entry.isDirectory()) continue;
+    const folder = path.join(quarantine, entry.name);
+    if (!pathExists(folder) || !isDir(folder)) continue;
+    const resolved = realPath(folder);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    roots.push({
+      scopeId: "quarantine",
+      scopeLabel: "Quarantine",
+      root: resolved,
+      kind: "quarantine",
+      recursive: false,
+      fromScope: entry.name
+    });
+  }
+  return roots;
+}
+function tokenEstimateFor(text) {
+  return Math.ceil(text.length / 4);
+}
+function collectDirectSkills(root, list, nested = false, depth = 0) {
+  if (nested && depth > 14) return;
+  for (const entry of readDirents(root.root)) {
+    if (SKIP_WALK.has(entry.name)) continue;
+    const abs = path.resolve(path.join(root.root, entry.name));
+    const install = describeInstall(abs);
+    if (install.link && !install.file && !isDir(abs)) {
+      list.push({ dir: abs, skillMd: abs, root, ...install, file: false, dangling: true });
+      continue;
+    }
+    if (isDir(abs)) {
+      const skillMd = findSkillFile(abs);
+      if (skillMd) {
+        list.push({ dir: abs, skillMd, root, ...install, file: false });
+      } else if (nested) {
+        collectDirectSkills({ ...root, root: abs }, list, true, depth + 1);
+      }
+      continue;
+    }
+    if (install.file && isSkillFileName(entry.name)) {
+      list.push({ dir: abs, skillMd: abs, root, ...install, file: true });
+    }
+  }
+}
+function walkSkillContainers(dir, root, list, depth = 0) {
+  if (depth > 14) return;
+  const entries = readDirents(dir);
+  const base = path.basename(dir);
+  if (base === "skills" || base === "skill") {
+    collectDirectSkills({ ...root, root: dir }, list);
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    if (SKIP_WALK.has(entry.name)) continue;
+    walkSkillContainers(path.join(dir, entry.name), root, list, depth + 1);
+  }
+}
+function dirSizeAndFiles(dir) {
+  try {
+    const followed = fs.statSync(dir);
+    if (followed.isFile()) {
+      return { files: [{ path: path.basename(dir), size: followed.size, mtime: followed.mtimeMs }], bytes: followed.size };
+    }
+  } catch {
+  }
+  const files = [];
+  let bytes = 0;
+  const walk = (current, rel, depth) => {
+    if (depth > 8 || files.length > 250) return;
+    for (const entry of readDirents(current)) {
+      if (SKIP_WALK.has(entry.name)) continue;
+      const abs = path.join(current, entry.name);
+      const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        walk(abs, nextRel, depth + 1);
+      } else if (entry.isFile()) {
+        let size = 0;
+        let mtime = 0;
+        try {
+          const st = fs.statSync(abs);
+          size = st.size;
+          mtime = st.mtimeMs;
+          bytes += size;
+        } catch {
+        }
+        files.push({ path: nextRel, size, mtime });
+      }
+    }
+  };
+  walk(dir, "", 0);
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return { files, bytes };
+}
+function danglingSummary(item) {
+  const { dir, root } = item;
+  let mtime = 0;
+  try {
+    mtime = fs.lstatSync(dir).mtimeMs;
+  } catch {
+  }
+  const base = path.basename(dir);
+  const slug = base.replace(/\.md$/i, "");
+  return {
+    id: idFor(dir),
+    name: slug,
+    slug,
+    description: "",
+    frontmatter: {},
+    scopeId: root.scopeId,
+    scopeLabel: root.scopeLabel,
+    kind: root.kind,
+    path: dir,
+    skillFile: dir,
+    skillRel: base,
+    file: false,
+    link: true,
+    linkTarget: item.linkTarget || "",
+    origin: null,
+    invocation: "model",
+    invocationEvidence: "",
+    contentHash: null,
+    risk: "none",
+    findings: [],
+    copies: [],
+    mtime,
+    skillSize: 0,
+    tokenEstimate: 0,
+    physicality: "broken",
+    refTarget: "",
+    refSkillId: "",
+    quarantined: root.kind === "quarantine",
+    fromScope: root.fromScope || ""
+  };
+}
+function summarizeSkill(item, memo, realpaths, origins) {
+  const { dir, skillMd, root } = item;
+  if (item.dangling) return danglingSummary(item);
+  const identity = item.dev || item.ino ? `${item.dev}:${item.ino}` : realPath(dir);
+  const memoKey = `${identity}|${item.file ? "file" : "dir"}`;
+  let shared = memo.get(memoKey);
+  if (!shared) {
+    let mtime = 0;
+    let size = 0;
+    let raw;
+    try {
+      const st = fs.statSync(skillMd);
+      mtime = st.mtimeMs;
+      size = st.size;
+      raw = fs.readFileSync(skillMd);
+    } catch {
+      return null;
+    }
+    const text = raw.toString("utf8");
+    const { data } = parseFrontmatter(text);
+    shared = {
+      data,
+      mtime,
+      size,
+      text,
+      contentHash: nodeCrypto.createHash("sha256").update(raw).digest("hex"),
+      audited: auditSkill({ root: dir, skillFile: skillMd, text, fileOnly: Boolean(item.file) })
+    };
+    memo.set(memoKey, shared);
+  }
+  let refTarget = "";
+  if (item.link) {
+    refTarget = realpaths.get(identity) || "";
+    if (!refTarget) {
+      refTarget = realPath(dir);
+      realpaths.set(identity, refTarget);
+    }
+  }
+  const base = path.basename(dir);
+  const slug = item.file ? base.replace(/\.md$/i, "") : base;
+  const name = stringField(shared.data, "name") || stringField(shared.data, "displayName") || slug;
+  const description = stringField(shared.data, "description");
+  const when = skillInvocation({ skillDir: dir, fileOnly: Boolean(item.file), frontmatter: shared.data, description });
+  return {
+    id: idFor(dir),
+    name,
+    slug,
+    description,
+    frontmatter: shared.data,
+    scopeId: root.scopeId,
+    scopeLabel: root.scopeLabel,
+    kind: root.kind,
+    path: dir,
+    skillFile: skillMd,
+    skillRel: path.basename(skillMd),
+    file: Boolean(item.file),
+    link: Boolean(item.link),
+    linkTarget: item.linkTarget || "",
+    origin: inferOrigin(dir, shared.data, item.linkTarget, origins),
+    invocation: when.invocation,
+    invocationEvidence: when.invocationEvidence,
+    contentHash: shared.contentHash,
+    risk: shared.audited.severity,
+    findings: shared.audited.findings.slice(),
+    copies: [],
+    mtime: shared.mtime,
+    skillSize: shared.size,
+    tokenEstimate: tokenEstimateFor(shared.text),
+    physicality: item.link ? "reference" : "physical",
+    refTarget,
+    refSkillId: "",
+    quarantined: root.kind === "quarantine",
+    fromScope: root.fromScope || ""
+  };
+}
+function attachCopies(skills) {
+  const byHash = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    if (skill.physicality !== "physical") continue;
+    if (!skill.contentHash) continue;
+    const list = byHash.get(skill.contentHash) || [];
+    list.push(skill);
+    byHash.set(skill.contentHash, list);
+  }
+  for (const skill of skills) {
+    if (skill.physicality !== "physical") {
+      skill.copies = [];
+      continue;
+    }
+    const group = skill.contentHash && byHash.get(skill.contentHash) || [];
+    skill.copies = group.filter((other) => other.id !== skill.id).map((other) => ({ id: other.id, scopeLabel: other.scopeLabel, path: other.path }));
+  }
+  return skills;
+}
+function censusOf(skills) {
+  const live = skills.filter((skill) => !skill.quarantined);
+  const physical = live.filter((skill) => skill.physicality === "physical");
+  const byHash = /* @__PURE__ */ new Map();
+  for (const skill of physical) {
+    if (!skill.contentHash) continue;
+    byHash.set(skill.contentHash, (byHash.get(skill.contentHash) || 0) + 1);
+  }
+  let duplicateCopies = 0;
+  let duplicateBytes = 0;
+  let tokenEstimate = 0;
+  for (const skill of physical) {
+    tokenEstimate += skill.tokenEstimate;
+    const twins = skill.contentHash && byHash.get(skill.contentHash) || 1;
+    if (twins > 1) {
+      duplicateCopies += 1;
+      duplicateBytes += dirSizeAndFiles(skill.path).bytes;
+    }
+  }
+  return {
+    total: live.length,
+    physical: physical.length,
+    unique: byHash.size,
+    duplicateCopies,
+    duplicateBytes,
+    references: live.filter((skill) => skill.physicality === "reference").length,
+    broken: live.filter((skill) => skill.physicality === "broken").length,
+    duplicates: duplicateCopies,
+    tokenEstimate
+  };
+}
+function scanRoots(roots, opts) {
+  const origins = createOriginContext(homeOf(opts));
+  const memo = /* @__PURE__ */ new Map();
+  const realpaths = /* @__PURE__ */ new Map();
+  const found = [];
+  for (const root of roots) {
+    if (root.deep) {
+      collectDirectSkills(root, found, true);
+    } else if (root.recursive) {
+      walkSkillContainers(root.root, root, found);
+    } else {
+      collectDirectSkills(root, found);
+    }
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const item of found) byPath.set(item.dir, item);
+  const skills = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const item of byPath.values()) {
+    const summary = summarizeSkill(item, memo, realpaths, origins);
+    if (!summary) continue;
+    skills.push(summary);
+    byId.set(summary.id, summary);
+  }
+  const byReal = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    if (skill.physicality === "physical") byReal.set(realPath(skill.path), skill.id);
+  }
+  for (const skill of skills) {
+    if (skill.physicality === "reference") skill.refSkillId = byReal.get(skill.refTarget) || "";
+  }
+  attachCopies(skills);
+  skills.sort((a, b) => {
+    const scope = a.scopeLabel.localeCompare(b.scopeLabel);
+    if (scope !== 0) return scope;
+    return a.name.localeCompare(b.name);
+  });
+  return { roots, skills, byId, census: censusOf(skills) };
+}
+function scanSkills(opts) {
+  return scanRoots(discoverRoots(opts), opts);
+}
+function toCatalogSkill(skill) {
+  return {
+    id: skill.id,
+    name: skill.name,
+    slug: skill.slug,
+    description: skill.description,
+    scopeId: skill.scopeId,
+    scopeLabel: skill.scopeLabel,
+    kind: skill.kind,
+    path: skill.path,
+    skillRel: skill.skillRel,
+    file: skill.file,
+    link: skill.link,
+    linkTarget: skill.linkTarget,
+    origin: skill.origin,
+    invocation: skill.invocation,
+    invocationEvidence: skill.invocationEvidence,
+    risk: skill.risk,
+    physicality: skill.physicality,
+    refTarget: skill.refTarget,
+    refSkillId: skill.refSkillId,
+    copyCount: skill.copies.length,
+    copies: skill.copies,
+    mtime: skill.mtime,
+    quarantined: Boolean(skill.quarantined),
+    fromScope: skill.fromScope || "",
+    skillSize: skill.skillSize,
+    tokenEstimate: skill.tokenEstimate
+  };
+}
+function readSkill(summary) {
+  const { skillFile, ...rest } = summary;
+  const base = { ...rest, copyCount: summary.copies.length };
+  if (summary.physicality === "broken") {
+    return { ...base, frontmatter: {}, frontmatterRaw: "", body: "", source: "", files: [], bytes: 0 };
+  }
+  const text = fs.readFileSync(skillFile, "utf8");
+  const { data, content, raw } = parseFrontmatter(text);
+  const { files, bytes } = dirSizeAndFiles(summary.path);
+  return { ...base, frontmatter: data, frontmatterRaw: raw, body: content, source: text, files, bytes };
+}
+const TEXT_EXTENSIONS = /\.(md|txt|ya?ml|json|js|mjs|cjs|ts|tsx|jsx|py|sh|html|css|svg|toml|xml|csv|rst)$/i;
+const MAX_PREVIEW_BYTES = 15e5;
+function readSkillFile(summary, relPath) {
+  if (summary.file) {
+    const abs2 = realPath(summary.skillFile);
+    const st2 = fs.statSync(abs2);
+    if (st2.size > MAX_PREVIEW_BYTES) throw fail(413, "File too large to preview");
+    return { path: path.basename(summary.skillFile), size: st2.size, binary: false, content: fs.readFileSync(abs2).toString("utf8") };
+  }
+  const abs = realPath(path.resolve(summary.path, path.normalize(relPath)));
+  const root = realPath(summary.path);
+  if (abs !== root && !abs.startsWith(root + path.sep)) throw fail(400, "Path escapes skill directory");
+  if (!pathExists(abs) || isDir(abs)) throw fail(404, "File not found");
+  const st = fs.statSync(abs);
+  if (st.size > MAX_PREVIEW_BYTES) throw fail(413, "File too large to preview");
+  const buf = fs.readFileSync(abs);
+  const looksText = !buf.includes(0) && TEXT_EXTENSIONS.test(abs);
+  return { path: path.relative(root, abs), size: st.size, binary: !looksText, content: looksText ? buf.toString("utf8") : null };
+}
+function assertSkillTarget(summary, roots, action = "delete", opts) {
+  const target = path.resolve(summary.path);
+  const inside = roots.some((r) => contained(target, r.root));
+  if (!inside) throw fail(403, "Skill is outside known cabinet roots");
+  const isRoot = roots.some((r) => path.resolve(r.root) === target);
+  if (isRoot || target === homeOf(opts)) throw fail(403, `Refusing to ${action} a cabinet root`);
+  const install = describeInstall(target);
+  const isDeadLink = install.link && !install.file && !isDir(target);
+  const isFolderSkill = isDir(target) && findSkillFile(target);
+  const isFileSkill = install.file && isSkillFileName(path.basename(target));
+  if (!isDeadLink && !isFolderSkill && !isFileSkill) throw fail(400, "Not a skill path");
+  return target;
+}
+function assertDeletable(summary, roots, opts) {
+  return assertSkillTarget(summary, roots, "delete", opts);
+}
+function deleteSkillDir(target) {
+  const st = fs.lstatSync(target);
+  if (st.isSymbolicLink() || st.isFile()) {
+    fs.unlinkSync(target);
+    return;
+  }
+  fs.rmSync(target, { recursive: true, force: false });
+}
+
+const CATALOG_TTL_MS = 15e3;
+let state = { at: 0, index: null };
+function getIndex(opts = {}) {
+  var _a;
+  const now = (_a = opts.now) != null ? _a : Date.now;
+  if (!opts.force && state.index && now() - state.at < CATALOG_TTL_MS) return state.index;
+  const index = scanSkills(opts);
+  state = { at: now(), index };
+  return index;
+}
+function invalidate() {
+  state = { at: 0, index: null };
+}
+function scannedAt() {
+  return state.at;
+}
+
+export { assertSkillTarget as a, readSkill as b, contained as c, readSkillFile as d, assertDeletable as e, deleteSkillDir as f, getIndex as g, homeOf as h, invalidate as i, isDir as j, quarantineRoot as q, realPath as r, scannedAt as s, toCatalogSkill as t };