@danieldeusing/seedr 0.1.87 → 0.1.89

package/dist/chunk-JC6HFAZU.js

@@ -0,0 +1,1188 @@
+#!/usr/bin/env node
+
+// src/config/registry.ts
+import { readFile as readFile3, readdir, writeFile as writeFile2, mkdir as mkdir2, mkdtemp, rm as rm2 } from "fs/promises";
+import { existsSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+
+// ../registry-ops/src/paths.ts
+var ALL_TYPES = ["skill", "plugin", "hook", "agent", "mcp", "settings", "command"];
+var KNOWN_TYPES = new Set(ALL_TYPES);
+function typeDirName(type) {
+  return type === "settings" || type === "mcp" ? type : `${type}s`;
+}
+
+// ../registry-ops/src/agents.ts
+var CANONICAL_AGENTS = ["claude", "copilot", "antigravity", "codex", "opencode"];
+var AGENT_ALIASES = { gemini: "antigravity" };
+var KNOWN_AGENTS = [...CANONICAL_AGENTS, ...Object.keys(AGENT_ALIASES)];
+function isCanonicalAgent(value) {
+  return typeof value === "string" && CANONICAL_AGENTS.includes(value);
+}
+function isLegacyAgent(value) {
+  return typeof value === "string" && Object.hasOwn(AGENT_ALIASES, value);
+}
+function canonicalAgent(value) {
+  if (isCanonicalAgent(value)) return value;
+  if (isLegacyAgent(value)) return AGENT_ALIASES[value];
+  return null;
+}
+function canonicalAgents(values) {
+  const present = new Set(values.map(canonicalAgent).filter((a) => a !== null));
+  return CANONICAL_AGENTS.filter((a) => present.has(a));
+}
+
+// ../registry-ops/src/sourceTypes.ts
+var CANONICAL_SOURCE_TYPES = ["official", "seedr", "community"];
+var SOURCE_TYPE_ALIASES = { toolr: "seedr" };
+var KNOWN_SOURCE_TYPES = [...CANONICAL_SOURCE_TYPES, ...Object.keys(SOURCE_TYPE_ALIASES)];
+function isCanonicalSourceType(value) {
+  return typeof value === "string" && CANONICAL_SOURCE_TYPES.includes(value);
+}
+function isLegacySourceType(value) {
+  return typeof value === "string" && Object.hasOwn(SOURCE_TYPE_ALIASES, value);
+}
+function canonicalSourceType(value) {
+  if (isCanonicalSourceType(value)) return value;
+  if (isLegacySourceType(value)) return SOURCE_TYPE_ALIASES[value];
+  return null;
+}
+function isFirstParty(sourceType) {
+  return canonicalSourceType(sourceType) === "seedr";
+}
+
+// src/utils/slug.ts
+var SLUG_PATTERN2 = /^[a-z0-9][a-z0-9-]*$/;
+var MAX_SLUG_LENGTH2 = 100;
+function isValidSlug2(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_SLUG_LENGTH2 && SLUG_PATTERN2.test(value);
+}
+function assertValidSlug(value, what = "item slug") {
+  if (!isValidSlug2(value)) {
+    throw new Error(
+      `Invalid ${what}: ${JSON.stringify(value)} (expected ${SLUG_PATTERN2.source}, at most ${MAX_SLUG_LENGTH2} characters)`
+    );
+  }
+}
+
+// src/utils/digest.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import { join } from "path";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function digestFromFileHashes(entries) {
+  const sorted = [...entries].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  let buffer = "";
+  for (const entry of sorted) {
+    buffer += `${entry.path}
+${entry.sha256}
+`;
+  }
+  return sha256Hex(buffer);
+}
+async function computeContentDigest(root, relativePaths) {
+  const entries = await Promise.all(
+    relativePaths.map(async (relativePath) => ({
+      path: relativePath,
+      sha256: sha256Hex(await readFile(join(root, ...relativePath.split("/"))))
+    }))
+  );
+  return digestFromFileHashes(entries);
+}
+function flattenFileTree(nodes, prefix = "") {
+  const paths = [];
+  for (const node of nodes) {
+    const path = prefix ? `${prefix}/${node.name}` : node.name;
+    if (node.type === "directory") {
+      if (node.children) paths.push(...flattenFileTree(node.children, path));
+    } else {
+      paths.push(path);
+    }
+  }
+  return paths;
+}
+function canonicalFileSet(files, license) {
+  const paths = flattenFileTree(files);
+  if (license?.installAs && !paths.includes(license.installAs)) {
+    paths.push(license.installAs);
+  }
+  return paths;
+}
+
+// src/utils/fs.ts
+import {
+  access,
+  mkdir,
+  symlink,
+  copyFile,
+  readFile as readFile2,
+  writeFile,
+  unlink,
+  readlink,
+  lstat,
+  stat,
+  realpath,
+  rename,
+  cp,
+  rm
+} from "fs/promises";
+import { randomBytes } from "crypto";
+import { homedir } from "os";
+import { basename, dirname, join as join2, relative, resolve, isAbsolute, sep } from "path";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function assertOverwritable(path, force) {
+  if (!force && await exists(path)) {
+    throw new Error(`${path} already exists; pass --force to overwrite`);
+  }
+}
+var SAFE_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var MAX_SEGMENT_LENGTH = 100;
+function assertSafePathSegment(value, what) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${what} must be a non-empty string`);
+  }
+  if (value.length > MAX_SEGMENT_LENGTH) {
+    throw new Error(`${what} is too long (${value.length} characters, maximum ${MAX_SEGMENT_LENGTH})`);
+  }
+  if (value.includes("..") || !SAFE_SEGMENT_PATTERN.test(value)) {
+    throw new Error(
+      `Unsafe ${what}: ${JSON.stringify(value)} (allowed: letters, digits, ".", "_" and "-"; no leading "-", no "..")`
+    );
+  }
+}
+function isStrictDescendant(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel !== "" && !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function isSameOrDescendant(root, candidate) {
+  return relative(root, candidate) === "" || isStrictDescendant(root, candidate);
+}
+async function realpathOrNull(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return null;
+  }
+}
+async function resolveContained(root, ...segments) {
+  const absoluteRoot = resolve(root);
+  const resolved = resolve(absoluteRoot, ...segments);
+  if (!isStrictDescendant(absoluteRoot, resolved)) {
+    throw new Error(`Refusing path outside ${absoluteRoot}: ${resolved}`);
+  }
+  const realRoot = await realpathOrNull(absoluteRoot);
+  if (realRoot === null) {
+    return resolved;
+  }
+  let ancestor = dirname(resolved);
+  for (; ; ) {
+    const realAncestor = await realpathOrNull(ancestor);
+    if (realAncestor !== null) {
+      if (!isSameOrDescendant(realRoot, realAncestor)) {
+        throw new Error(
+          `Refusing path outside ${absoluteRoot}: ${ancestor} resolves to ${realAncestor}`
+        );
+      }
+      return resolved;
+    }
+    const parent = dirname(ancestor);
+    if (parent === ancestor || relative(absoluteRoot, ancestor) === "") {
+      return resolved;
+    }
+    ancestor = parent;
+  }
+}
+async function assertDirectoryWithin(dir, scopeRoot, what) {
+  const realRoot = await realpathOrNull(resolve(scopeRoot));
+  const realDir = await realpathOrNull(resolve(dir));
+  if (realRoot === null || realDir === null) {
+    throw new Error(`${what} ${dir} could not be resolved`);
+  }
+  if (!isSameOrDescendant(realRoot, realDir)) {
+    throw new Error(`${what} ${dir} resolves to ${realDir}, outside ${scopeRoot}`);
+  }
+}
+async function removePathEntry(path) {
+  let stats;
+  try {
+    stats = await lstat(path);
+  } catch (error2) {
+    if (error2.code === "ENOENT") return false;
+    throw error2;
+  }
+  if (stats.isDirectory()) {
+    await rm(path, { recursive: true, force: true });
+  } else {
+    await unlink(path);
+  }
+  return true;
+}
+async function moveDirectory(source, destination) {
+  await mkdir(dirname(destination), { recursive: true });
+  try {
+    await rename(source, destination);
+  } catch (error2) {
+    if (error2.code !== "EXDEV") throw error2;
+    await cp(source, destination, { recursive: true });
+    await rm(source, { recursive: true, force: true });
+  }
+}
+async function writeFileAtomic(path, data, options = {}) {
+  const tempPath = join2(dirname(path), `${basename(path)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    await writeFile(tempPath, data, options.mode === void 0 ? {} : { mode: options.mode });
+    await rename(tempPath, path);
+  } catch (error2) {
+    await unlink(tempPath).catch(() => void 0);
+    throw error2;
+  }
+}
+async function snapshotFile(path) {
+  try {
+    const [content, stats] = await Promise.all([readFile2(path), stat(path)]);
+    return { content, mode: stats.mode & 511 };
+  } catch (error2) {
+    if (error2.code === "ENOENT") return { content: null };
+    throw error2;
+  }
+}
+async function restoreFile(path, snapshot) {
+  if (snapshot.content === null) {
+    await removePathEntry(path);
+    return;
+  }
+  await writeFileAtomic(path, snapshot.content, { mode: snapshot.mode });
+}
+async function installFile(source, destination, method) {
+  await ensureDir(dirname(destination));
+  await removePathEntry(destination);
+  if (method === "symlink") {
+    const relPath = relative(dirname(destination), source);
+    await symlink(relPath, destination);
+  } else {
+    await copyFile(source, destination);
+  }
+}
+async function writeTextFile(path, content) {
+  await ensureDir(dirname(path));
+  await writeFile(path, content, "utf-8");
+}
+function getAgentsPath(contentType, slug, scope, cwd) {
+  const base = scope === "user" ? homedir() : cwd;
+  return join2(base, ".agents", contentType + "s", slug);
+}
+async function copyDirectory(source, destination) {
+  await cp(source, destination, { recursive: true });
+}
+async function installDirectory(source, destination, method) {
+  await ensureDir(dirname(destination));
+  await removePathEntry(destination);
+  if (method === "symlink") {
+    const relPath = relative(dirname(destination), source);
+    await symlink(relPath, destination);
+  } else {
+    await copyDirectory(source, destination);
+  }
+}
+
+// src/config/source.ts
+var GITHUB_REPO_PATTERN = /^https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?(?:\/(.*))?$/;
+var COMMIT_SHA_PATTERN = /^[0-9a-f]{40}$/;
+var RAW_HOST = "https://raw.githubusercontent.com";
+function parseGitHubRepo(url) {
+  const match = GITHUB_REPO_PATTERN.exec(url);
+  if (!match) return null;
+  const owner = match[1];
+  const repo = match[2];
+  if (owner.includes("..") || repo.includes("..") || owner.startsWith(".") || repo.startsWith(".")) {
+    return null;
+  }
+  return { owner, repo, rest: match[3] ?? "" };
+}
+function assertSafeRepoPath(path, what) {
+  const trimmed = path.replace(/^\.\//, "").replace(/^\/+|\/+$/g, "");
+  if (trimmed === "") return "";
+  for (const segment of trimmed.split("/")) {
+    if (segment === "" || segment === "." || segment === ".." || segment.includes("\\")) {
+      throw new Error(`Unsafe ${what}: ${JSON.stringify(path)}`);
+    }
+  }
+  return trimmed;
+}
+function assertCommitSha(value, what) {
+  if (!value || !COMMIT_SHA_PATTERN.test(value)) {
+    throw new Error(`Invalid ${what}: ${JSON.stringify(value)} (expected 40 lowercase hex characters)`);
+  }
+  return value;
+}
+function rawUrl(owner, repo, ref, path) {
+  const base = `${RAW_HOST}/${owner}/${repo}/${ref}`;
+  return path ? `${base}/${path}` : base;
+}
+function parseExternalUrl(externalUrl) {
+  const parsed = parseGitHubRepo(externalUrl);
+  if (!parsed) {
+    throw new Error(`unsupported source host: ${externalUrl}`);
+  }
+  if (parsed.rest === "") {
+    return { owner: parsed.owner, repo: parsed.repo, branch: null, path: "" };
+  }
+  const treeMatch = /^tree\/([^/]+)(?:\/(.*))?$/.exec(parsed.rest);
+  if (!treeMatch) {
+    throw new Error(`unsupported source URL: ${externalUrl}`);
+  }
+  return {
+    owner: parsed.owner,
+    repo: parsed.repo,
+    branch: treeMatch[1],
+    path: assertSafeRepoPath(treeMatch[2] ?? "", "externalUrl path")
+  };
+}
+function getEffectiveSourceRevision(item) {
+  return item.pluginSource?.sha ?? item.sourceRevision;
+}
+function resolvePluginSource(item) {
+  const source = item.pluginSource;
+  const what = `pluginSource of "${item.slug}"`;
+  if (source.kind === "marketplace-path") {
+    const marketplace = item.marketplaceRef;
+    if (!marketplace) {
+      throw new Error(`${what} is marketplace-path but the item has no marketplaceRef`);
+    }
+    const repo2 = parseGitHubRepo(marketplace.url);
+    if (!repo2) throw new Error(`unsupported source host: ${marketplace.url}`);
+    const sha2 = assertCommitSha(marketplace.sha || source.sha, `marketplaceRef.sha of "${item.slug}"`);
+    const path2 = assertSafeRepoPath(source.path ?? "", `${what} path`);
+    return {
+      baseUrl: rawUrl(repo2.owner, repo2.repo, sha2, path2),
+      rootUrl: rawUrl(repo2.owner, repo2.repo, sha2, ""),
+      revision: sha2
+    };
+  }
+  if (!source.url) {
+    throw new Error(`${what} (${source.kind}) has no url`);
+  }
+  const repo = parseGitHubRepo(source.url);
+  if (!repo) throw new Error(`unsupported source host: ${source.url}`);
+  const sha = assertCommitSha(source.sha, `pluginSource.sha of "${item.slug}"`);
+  const path = source.kind === "git-subdir" ? assertSafeRepoPath(source.path ?? "", `${what} path`) : "";
+  return {
+    baseUrl: rawUrl(repo.owner, repo.repo, sha, path),
+    rootUrl: rawUrl(repo.owner, repo.repo, sha, ""),
+    revision: sha
+  };
+}
+function resolveItemSource(item) {
+  if (item.pluginSource) {
+    return resolvePluginSource(item);
+  }
+  if (!item.externalUrl) {
+    throw new Error(`Item "${item.slug}" has no externalUrl to fetch from`);
+  }
+  const { owner, repo, branch, path } = parseExternalUrl(item.externalUrl);
+  if (item.sourceRevision !== void 0) {
+    const sha = assertCommitSha(item.sourceRevision, `sourceRevision of "${item.slug}"`);
+    return { baseUrl: rawUrl(owner, repo, sha, path), rootUrl: rawUrl(owner, repo, sha, ""), revision: sha };
+  }
+  const ref = branch ?? "main";
+  return { baseUrl: rawUrl(owner, repo, ref, path), rootUrl: rawUrl(owner, repo, ref, ""), revision: null };
+}
+
+// src/config/registry.ts
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
+var FETCH_TIMEOUT_MS = 15e3;
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    if (existsSync(join3(dir, "package.json"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function resolveLocalRegistryPath() {
+  const packageRoot = findPackageRoot(__dirname2);
+  if (!packageRoot) return null;
+  return join3(packageRoot, "..", "..", "registry");
+}
+var REGISTRY_PATH = process.env.SEEDR_REGISTRY_DIR || resolveLocalRegistryPath();
+var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/danieldeusing/seedr/main/registry";
+var REGISTRY_URL = (process.env.SEEDR_REGISTRY_URL || DEFAULT_REGISTRY_URL).replace(/\/+$/, "");
+var REGISTRY_ROOT_URL = REGISTRY_URL.replace(/\/registry$/, "");
+function assertSafeNodeName(name) {
+  if (name === "" || name === "." || name.includes("/") || name.includes("\\") || name.includes("..")) {
+    throw new Error(`Unsafe file name in registry content: ${JSON.stringify(name)}`);
+  }
+}
+var cache = {
+  index: null,
+  types: /* @__PURE__ */ new Map(),
+  assembled: null
+};
+function isValidManifestIndex(value) {
+  return typeof value === "object" && value !== null && typeof value.types === "object" && value.types !== null;
+}
+async function loadFile(filename) {
+  if (REGISTRY_PATH) {
+    try {
+      return await readFile3(join3(REGISTRY_PATH, filename), "utf-8");
+    } catch {
+    }
+  }
+  return fetchRemote(`${REGISTRY_URL}/${filename}`);
+}
+async function fetchResponse(url) {
+  let response;
+  try {
+    response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  } catch (error2) {
+    if (error2 instanceof Error && error2.name === "TimeoutError") {
+      throw new Error(`Registry unreachable: timed out fetching ${url}`, { cause: error2 });
+    }
+    throw new Error(`Registry unreachable: ${url}`, { cause: error2 });
+  }
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+  }
+  return response;
+}
+async function fetchRemote(url) {
+  const response = await fetchResponse(url);
+  return response.text();
+}
+async function fetchRemoteBuffer(url) {
+  const response = await fetchResponse(url);
+  return Buffer.from(await response.arrayBuffer());
+}
+async function loadIndex() {
+  if (cache.index) return cache.index;
+  if (REGISTRY_PATH) {
+    try {
+      const localContent = await readFile3(join3(REGISTRY_PATH, "manifest.json"), "utf-8");
+      const parsed = JSON.parse(localContent);
+      if (isValidManifestIndex(parsed)) {
+        cache.index = parsed;
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  const content = await fetchRemote(`${REGISTRY_URL}/manifest.json`);
+  const data = JSON.parse(content);
+  cache.index = data;
+  return data;
+}
+async function loadTypeItems(type) {
+  const cached = cache.types.get(type);
+  if (cached) return cached;
+  const index = await loadIndex();
+  const desc = index.types[type];
+  const content = await loadFile(desc.file);
+  const typeManifest = JSON.parse(content);
+  cache.types.set(type, typeManifest.items);
+  return typeManifest.items;
+}
+async function loadManifest() {
+  if (cache.assembled) return cache.assembled;
+  const index = await loadIndex();
+  const typeEntries = Object.entries(index.types);
+  const typeResults = await Promise.all(
+    typeEntries.map(async ([type]) => loadTypeItems(type))
+  );
+  const items = typeResults.flat();
+  const manifest = { version: index.version, items };
+  cache.assembled = manifest;
+  return manifest;
+}
+async function getItem(slug, type) {
+  const manifest = await loadManifest();
+  if (type) return manifest.items.find((item) => item.slug === slug && item.type === type);
+  return manifest.items.find((item) => item.slug === slug);
+}
+async function getItemsBySlug(slug) {
+  const manifest = await loadManifest();
+  return manifest.items.filter((item) => item.slug === slug);
+}
+async function listItems(type) {
+  if (type) {
+    return loadTypeItems(type);
+  }
+  const manifest = await loadManifest();
+  return manifest.items;
+}
+async function searchItems(query) {
+  const manifest = await loadManifest();
+  const lowerQuery = query.toLowerCase();
+  return manifest.items.filter(
+    (item) => item.slug.toLowerCase().includes(lowerQuery) || item.name.toLowerCase().includes(lowerQuery) || item.description.toLowerCase().includes(lowerQuery)
+  );
+}
+async function getItemFull(item) {
+  assertValidSlug(item.slug);
+  const typeDir = typeDirName(item.type);
+  const itemJsonPath = `${typeDir}/${item.slug}/item.json`;
+  const content = await loadFile(itemJsonPath);
+  return JSON.parse(content);
+}
+function getItemBaseUrl(item) {
+  if (isFirstParty(item.sourceType)) {
+    assertValidSlug(item.slug);
+    const typeDir = typeDirName(item.type);
+    return {
+      local: REGISTRY_PATH ? join3(REGISTRY_PATH, typeDir, item.slug) : null,
+      remote: `${REGISTRY_URL}/${typeDir}/${item.slug}`,
+      rootUrl: REGISTRY_ROOT_URL,
+      revision: null
+    };
+  }
+  const source = resolveItemSource(item);
+  return { local: null, remote: source.baseUrl, rootUrl: source.rootUrl, revision: source.revision };
+}
+function mainFileName(type) {
+  return type === "skill" ? "SKILL.md" : `${type}.md`;
+}
+async function getItemContent(item) {
+  const { local } = getItemBaseUrl(item);
+  const mainFile = mainFileName(item.type);
+  if (local) {
+    try {
+      return await readFile3(join3(local, mainFile), "utf-8");
+    } catch {
+    }
+  }
+  const tempRoot = await mkdtemp(join3(tmpdir(), "seedr-content-"));
+  try {
+    const destination = join3(tempRoot, "item");
+    await fetchItemToDestination(item, destination);
+    return await readFile3(join3(destination, mainFile), "utf-8");
+  } finally {
+    await rm2(tempRoot, { recursive: true, force: true });
+  }
+}
+async function fetchItemFile(item, relativePath) {
+  const segments = relativePath.split("/");
+  for (const segment of segments) assertSafeNodeName(segment);
+  const { local, remote } = getItemBaseUrl(item);
+  if (local) {
+    try {
+      return await readFile3(join3(local, ...segments), "utf-8");
+    } catch {
+    }
+  }
+  return fetchRemote(`${remote}/${relativePath}`);
+}
+function getItemSourcePath(item) {
+  if (!isFirstParty(item.sourceType)) {
+    return null;
+  }
+  if (!REGISTRY_PATH) {
+    return null;
+  }
+  assertValidSlug(item.slug);
+  const typeDir = typeDirName(item.type);
+  return join3(REGISTRY_PATH, typeDir, item.slug);
+}
+function integrityError(item, detail) {
+  return new Error(`Registry integrity error: ${item.type} "${item.slug}" \u2014 ${detail}`);
+}
+function legacyFileList(item) {
+  if (item.type === "skill") return ["SKILL.md"];
+  if (item.type === "plugin") return [".claude-plugin/plugin.json"];
+  return [mainFileName(item.type)];
+}
+async function resolveFileSet(item) {
+  let files = item.contents?.files;
+  let license = item.license;
+  let digest = item.contentDigest ?? null;
+  if (!files && item.type === "plugin") {
+    const full = await getItemFull(item);
+    files = full.contents?.files;
+    license ??= full.license;
+    if (full.contentDigest) {
+      if (digest !== null && full.contentDigest !== digest) {
+        throw integrityError(item, `manifest digest ${digest} disagrees with item.json digest ${full.contentDigest}`);
+      }
+      digest = full.contentDigest;
+    }
+  }
+  if (!files) {
+    return { paths: legacyFileList(item), digest, licenseExtra: null };
+  }
+  const treePaths = flattenFileTree(files);
+  const paths = canonicalFileSet(files, license);
+  let licenseExtra = null;
+  if (license?.installAs && !treePaths.includes(license.installAs)) {
+    if (!license.file) {
+      throw integrityError(item, `license.installAs "${license.installAs}" is set without license.file`);
+    }
+    licenseExtra = { installAs: license.installAs, file: license.file };
+  }
+  return { paths, digest, licenseExtra };
+}
+async function downloadFileSet(location, fileSet, stagingDir) {
+  await Promise.all(fileSet.paths.map(async (relativePath) => {
+    const segments = relativePath.split("/");
+    for (const segment of segments) assertSafeNodeName(segment);
+    const url = fileSet.licenseExtra && relativePath === fileSet.licenseExtra.installAs ? `${location.rootUrl}/${fileSet.licenseExtra.file}` : `${location.remote}/${relativePath}`;
+    const content = await fetchRemoteBuffer(url);
+    const filePath = join3(stagingDir, ...segments);
+    await mkdir2(dirname2(filePath), { recursive: true });
+    await writeFile2(filePath, content);
+  }));
+}
+async function fetchItemToDestination(item, destPath) {
+  const location = getItemBaseUrl(item);
+  const fileSet = await resolveFileSet(item);
+  if (fileSet.digest === null && !isFirstParty(item.sourceType)) {
+    throw integrityError(item, "the registry entry carries no contentDigest; refusing to install unverifiable content");
+  }
+  await mkdir2(dirname2(destPath), { recursive: true });
+  const stagingDir = await mkdtemp(join3(dirname2(destPath), ".seedr-staging-"));
+  try {
+    await downloadFileSet(location, fileSet, stagingDir);
+    if (fileSet.digest !== null) {
+      const actual = await computeContentDigest(stagingDir, fileSet.paths);
+      if (actual !== fileSet.digest) {
+        throw integrityError(item, `content digest mismatch (expected ${fileSet.digest}, actual ${actual})`);
+      }
+    }
+    await removePathEntry(destPath);
+    await moveDirectory(stagingDir, destPath);
+  } finally {
+    await rm2(stagingDir, { recursive: true, force: true });
+  }
+  return { sourceRevision: location.revision, contentDigest: fileSet.digest, files: fileSet.paths };
+}
+
+// src/config/agents.ts
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+var home = homedir2();
+var SKILL_DIRECTORY = {
+  path: "skills"
+};
+var ANTIGRAVITY = {
+  name: "Google Antigravity",
+  shortName: "antigravity",
+  projectRoot: ".agents",
+  userRoot: join4(home, ".agents"),
+  contentTypes: { skill: SKILL_DIRECTORY }
+};
+var CODING_AGENTS = {
+  claude: {
+    name: "Claude Code",
+    shortName: "claude",
+    projectRoot: ".claude",
+    userRoot: join4(home, ".claude"),
+    contentTypes: {
+      skill: SKILL_DIRECTORY,
+      command: {
+        path: "commands"
+      },
+      agent: {
+        path: "agents"
+      },
+      hook: {
+        path: ""
+      },
+      plugin: {
+        path: "plugins/cache"
+      },
+      settings: {
+        path: ""
+      },
+      mcp: {
+        path: ""
+      }
+    }
+  },
+  copilot: {
+    name: "GitHub Copilot",
+    shortName: "copilot",
+    projectRoot: ".github",
+    userRoot: join4(home, ".github"),
+    contentTypes: { skill: SKILL_DIRECTORY }
+  },
+  antigravity: ANTIGRAVITY,
+  gemini: ANTIGRAVITY,
+  codex: {
+    name: "OpenAI Codex CLI",
+    shortName: "codex",
+    projectRoot: ".codex",
+    userRoot: join4(home, ".codex"),
+    contentTypes: { skill: SKILL_DIRECTORY }
+  },
+  opencode: {
+    name: "OpenCode",
+    shortName: "opencode",
+    projectRoot: ".opencode",
+    userRoot: join4(home, ".opencode"),
+    contentTypes: { skill: SKILL_DIRECTORY }
+  }
+};
+var ALL_AGENTS = [...CANONICAL_AGENTS];
+function getAgentConfig(agent) {
+  return CODING_AGENTS[agent];
+}
+function getContentTypeConfig(agent, type) {
+  return getAgentConfig(agent).contentTypes[type];
+}
+function getAgentRoot(agent, scope, cwd = process.cwd()) {
+  const config = getAgentConfig(agent);
+  switch (scope) {
+    case "project":
+    case "local":
+      return join4(cwd, config.projectRoot);
+    case "user":
+      return config.userRoot;
+  }
+}
+function getContentPath(agent, type, scope, cwd = process.cwd()) {
+  const typeConfig = getContentTypeConfig(agent, type);
+  if (!typeConfig) return void 0;
+  const root = getAgentRoot(agent, scope, cwd);
+  return typeConfig.path ? join4(root, typeConfig.path) : root;
+}
+function getSettingsPath(scope, cwd = process.cwd()) {
+  switch (scope) {
+    case "project":
+      return join4(cwd, ".claude/settings.json");
+    case "user":
+      return join4(home, ".claude/settings.json");
+    case "local":
+      return join4(cwd, ".claude/settings.local.json");
+  }
+}
+function getMcpConfigPath(agent, scope, cwd = process.cwd()) {
+  const isUser = scope === "user";
+  switch (canonicalAgent(agent) ?? agent) {
+    case "claude":
+      return isUser ? join4(home, ".claude.json") : join4(cwd, ".mcp.json");
+    case "codex":
+      return isUser ? join4(home, ".codex", "config.toml") : join4(cwd, ".codex", "config.toml");
+    case "opencode":
+      return isUser ? join4(home, ".config", "opencode", "opencode.json") : join4(cwd, "opencode.json");
+    default:
+      throw new Error(`${agent} has no verified MCP configuration format`);
+  }
+}
+function getAgentPath(agent, scope, cwd = process.cwd()) {
+  return getContentPath(agent, "skill", scope, cwd) || "";
+}
+
+// src/utils/detection.ts
+async function detectInstalledAgents(cwd = process.cwd()) {
+  const checks = ALL_AGENTS.flatMap((agent) => {
+    const projectPath = getAgentPath(agent, "project", cwd);
+    const userPath = getAgentPath(agent, "user", cwd);
+    return [
+      exists(projectPath).then((found) => found ? { agent, scope: "project", path: projectPath } : null),
+      exists(userPath).then((found) => found ? { agent, scope: "user", path: userPath } : null)
+    ];
+  });
+  const results = await Promise.all(checks);
+  return results.filter((r) => r !== null);
+}
+async function detectProjectAgents(cwd = process.cwd()) {
+  const checks = ALL_AGENTS.map(async (agent) => {
+    const projectPath = getAgentPath(agent, "project", cwd);
+    return await exists(projectPath) ? agent : null;
+  });
+  const results = await Promise.all(checks);
+  return results.filter((a) => a !== null);
+}
+async function isAgentInstalled(agent, scope, cwd = process.cwd()) {
+  const effectiveScope = scope === "local" ? "project" : scope;
+  const path = getAgentPath(agent, effectiveScope, cwd);
+  return exists(path);
+}
+function parseAgentArg(arg) {
+  const normalized = arg.toLowerCase().trim();
+  const aliases = {
+    "claude-code": "claude",
+    claudecode: "claude",
+    cc: "claude",
+    "github-copilot": "copilot",
+    gh: "copilot",
+    "google-antigravity": "antigravity",
+    agy: "antigravity",
+    "gemini-code": "antigravity",
+    gca: "antigravity",
+    "openai-codex": "codex",
+    oc: "opencode"
+  };
+  return canonicalAgent(aliases[normalized] ?? normalized);
+}
+function parseAgentsArgStrict(agents) {
+  const parsed = [];
+  const unknown = [];
+  for (const raw of agents.split(",")) {
+    const trimmed = raw.trim();
+    if (trimmed === "") continue;
+    const agent = parseAgentArg(trimmed);
+    if (agent === null) {
+      unknown.push(trimmed);
+    } else if (!parsed.includes(agent)) {
+      parsed.push(agent);
+    }
+  }
+  return { agents: parsed, unknown };
+}
+
+// src/utils/ui.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY);
+}
+function assertInteractive(question, flag) {
+  if (process.stdin.isTTY) return;
+  throw new Error(`${question} requires a terminal \u2014 pass ${flag} to run non-interactively`);
+}
+var brand = chalk.hex("#22c55e");
+var bgBrand = chalk.bgHex("#22c55e").black;
+var LOGO = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D`;
+var URLS = {
+  seedr: "https://seedr.danieldeusing.de"
+};
+function printLogo() {
+  console.log(brand(LOGO));
+  console.log(brand("  \u{1F331} Seed your Coding Agents with capabilities"));
+  console.log(chalk.gray(`  ${URLS.seedr}`));
+  console.log();
+}
+async function selectSkill(items) {
+  assertInteractive("Choosing an item", "the item name as an argument");
+  const result = await p.select({
+    message: "Select a skill to install",
+    options: items.map((item) => ({
+      label: item.name,
+      value: item,
+      hint: item.description
+    }))
+  });
+  return result;
+}
+async function selectAgents(compatible) {
+  assertInteractive("Choosing coding agents", "--agents");
+  const allOption = await p.select({
+    message: "Which coding agents do you want to install for?",
+    options: [
+      { label: `All (${compatible.length} agents)`, value: "all" },
+      { label: "Select specific agents...", value: "select" }
+    ]
+  });
+  if (p.isCancel(allOption)) return allOption;
+  if (allOption === "all") return compatible;
+  const result = await p.multiselect({
+    message: "Select agents",
+    options: compatible.map((agent) => ({
+      label: CODING_AGENTS[agent].name,
+      value: agent,
+      hint: CODING_AGENTS[agent].projectRoot
+    })),
+    initialValues: ["claude"],
+    required: true
+  });
+  return result;
+}
+async function selectScope(includeLocal = false) {
+  assertInteractive("Choosing an installation scope", "--scope");
+  const options = [
+    { label: "Project", value: "project", hint: includeLocal ? "current directory, settings.json" : "current directory" },
+    { label: "User", value: "user", hint: "home directory" },
+    ...includeLocal ? [{ label: "Local", value: "local", hint: "current directory, settings.local.json" }] : []
+  ];
+  const result = await p.select({ message: "Installation scope", options });
+  return result;
+}
+async function selectMethod(symlinkPath) {
+  assertInteractive("Choosing an installation method", "--method");
+  const result = await p.select({
+    message: "Installation method",
+    options: [
+      { label: "Symlink", value: "symlink", hint: `shared at ${symlinkPath}` },
+      { label: "Copy", value: "copy", hint: "standalone copy per agent" }
+    ]
+  });
+  return result;
+}
+async function confirm2(message) {
+  assertInteractive("Confirmation", "--yes");
+  return p.confirm({ message });
+}
+function intro2(message) {
+  p.intro(bgBrand(` ${message} `));
+}
+function outro2(message) {
+  p.outro(brand(message));
+}
+function step(message) {
+  p.log.step(message);
+}
+function info(message) {
+  p.log.info(message);
+}
+function success(message) {
+  p.log.success(message);
+}
+function warn(message) {
+  p.log.warn(message);
+}
+function error(message) {
+  p.log.error(message);
+}
+
+// src/handlers/skill.ts
+import { relative as relative2, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { readdir as readdir2, symlink as symlink2 } from "fs/promises";
+import chalk2 from "chalk";
+import ora from "ora";
+var SLUG_LABEL = "skill slug";
+var READS_CENTRAL_DIR = /* @__PURE__ */ new Set(["antigravity", "codex", "opencode"]);
+function getScopeRoot(scope, cwd) {
+  return scope === "user" ? homedir3() : cwd;
+}
+function centralSkillsDir(scope, cwd) {
+  return dirname3(getAgentsPath("skill", "any-slug", scope, cwd));
+}
+async function resolveCentralPath(slug, scope, cwd) {
+  const scopeRoot = getScopeRoot(scope, cwd);
+  const centralDir = centralSkillsDir(scope, cwd);
+  return resolveContained(scopeRoot, relative2(scopeRoot, centralDir), slug);
+}
+async function resolveAgentSkillPath(agent, slug, scope, cwd) {
+  const destDir = getContentPath(agent, "skill", scope, cwd);
+  if (!destDir) return null;
+  const scopeRoot = getScopeRoot(scope, cwd);
+  return resolveContained(scopeRoot, relative2(scopeRoot, destDir), slug);
+}
+async function installToCentralLocation(item, sourcePath, scope, force, cwd) {
+  const centralPath = await resolveCentralPath(item.slug, scope, cwd);
+  await assertOverwritable(centralPath, force);
+  const existed = await exists(centralPath);
+  if (sourcePath && await exists(sourcePath)) {
+    await installDirectory(sourcePath, centralPath, "copy");
+  } else {
+    await fetchItemToDestination(item, centralPath);
+  }
+  return { centralPath, created: !existed };
+}
+async function createAgentSymlink(centralPath, destPath) {
+  await ensureDir(dirname3(destPath));
+  await removePathEntry(destPath);
+  const relPath = relative2(dirname3(destPath), centralPath);
+  await symlink2(relPath, destPath);
+}
+async function installSkillForAgent(item, agent, scope, method, force, cwd, centralPath) {
+  const spinner = ora(
+    `Installing ${item.name} for ${CODING_AGENTS[agent].name}...`
+  ).start();
+  try {
+    const destPath = await resolveAgentSkillPath(agent, item.slug, scope, cwd);
+    if (!destPath) {
+      throw new Error(`${CODING_AGENTS[agent].name} does not support skills`);
+    }
+    await assertOverwritable(destPath, force);
+    const sourcePath = getItemSourcePath(item);
+    if (method === "symlink" && centralPath) {
+      await createAgentSymlink(centralPath, destPath);
+    } else if (sourcePath && await exists(sourcePath)) {
+      await installDirectory(sourcePath, destPath, "copy");
+    } else {
+      await fetchItemToDestination(item, destPath);
+    }
+    spinner.succeed(
+      brand(`Installed ${item.name} for ${CODING_AGENTS[agent].name}`)
+    );
+    return { agent, success: true, path: destPath };
+  } catch (error2) {
+    const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+    spinner.fail(
+      chalk2.red(`Failed to install for ${CODING_AGENTS[agent].name}: ${errorMsg}`)
+    );
+    return { agent, success: false, path: "", error: errorMsg };
+  }
+}
+async function installSkill(item, agents, scope, method, force, cwd = process.cwd()) {
+  assertValidSlug(item.slug, SLUG_LABEL);
+  const results = [];
+  const sourcePath = getItemSourcePath(item);
+  let central;
+  if (method === "symlink") {
+    central = await installToCentralLocation(item, sourcePath, scope, force, cwd);
+  }
+  for (const agent of agents) {
+    if (READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent) && central) {
+      results.push({ agent, success: true, path: central.centralPath });
+      continue;
+    }
+    const result = await installSkillForAgent(
+      item,
+      agent,
+      scope,
+      method,
+      force,
+      cwd,
+      central?.centralPath
+    );
+    results.push(result);
+  }
+  if (central?.created && !results.some((result) => result.success)) {
+    await removePathEntry(central.centralPath);
+  }
+  return results;
+}
+async function uninstallSkill(slug, agent, scope, cwd = process.cwd()) {
+  assertValidSlug(slug, SLUG_LABEL);
+  const destPath = await resolveAgentSkillPath(agent, slug, scope, cwd);
+  if (destPath && await removePathEntry(destPath)) return true;
+  if (READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent)) {
+    return removePathEntry(await resolveCentralPath(slug, scope, cwd));
+  }
+  return false;
+}
+async function getInstalledSkills(agent, scope, cwd = process.cwd()) {
+  const dirs = /* @__PURE__ */ new Set();
+  const own = getContentPath(agent, "skill", scope, cwd);
+  if (own) dirs.add(own);
+  if (READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent)) dirs.add(centralSkillsDir(scope, cwd));
+  const slugs = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    if (!await exists(dir)) continue;
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if ((entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith(".")) slugs.add(entry.name);
+    }
+  }
+  return [...slugs];
+}
+async function planSkill(item, agents, scope, method, cwd) {
+  assertValidSlug(item.slug, SLUG_LABEL);
+  const changes = [];
+  const kindFor = async (path) => await exists(path) ? "modify" : "create";
+  let centralPath;
+  if (method === "symlink") {
+    centralPath = await resolveCentralPath(item.slug, scope, cwd);
+    const sharedBy = agents.filter((agent) => READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent));
+    changes.push({
+      agent: "shared",
+      kind: await kindFor(centralPath),
+      path: centralPath,
+      detail: sharedBy.length > 0 ? `central copy, read directly by ${sharedBy.join(", ")}` : "central copy"
+    });
+  }
+  for (const agent of agents) {
+    if (centralPath && READS_CENTRAL_DIR.has(canonicalAgent(agent) ?? agent)) continue;
+    const destPath = await resolveAgentSkillPath(agent, item.slug, scope, cwd);
+    if (!destPath) throw new Error(`${CODING_AGENTS[agent].name} does not support skills`);
+    changes.push({
+      agent,
+      kind: await kindFor(destPath),
+      path: destPath,
+      detail: centralPath ? `symlink \u2192 ${centralPath}` : "skill directory"
+    });
+  }
+  return changes;
+}
+var skillHandler = {
+  type: "skill",
+  async install(item, agents, scope, method, force, cwd) {
+    return installSkill(item, agents, scope, method, force, cwd);
+  },
+  async uninstall(slug, agent, scope, cwd) {
+    return uninstallSkill(slug, agent, scope, cwd);
+  },
+  async listInstalled(agent, scope, cwd) {
+    return getInstalledSkills(agent, scope, cwd);
+  },
+  plan: planSkill
+};
+
+export {
+  isLegacyAgent,
+  canonicalAgent,
+  canonicalAgents,
+  SLUG_PATTERN2 as SLUG_PATTERN,
+  MAX_SLUG_LENGTH2 as MAX_SLUG_LENGTH,
+  isValidSlug2 as isValidSlug,
+  assertValidSlug,
+  exists,
+  ensureDir,
+  assertOverwritable,
+  assertSafePathSegment,
+  resolveContained,
+  assertDirectoryWithin,
+  removePathEntry,
+  moveDirectory,
+  writeFileAtomic,
+  snapshotFile,
+  restoreFile,
+  installFile,
+  writeTextFile,
+  getAgentsPath,
+  copyDirectory,
+  parseGitHubRepo,
+  getEffectiveSourceRevision,
+  loadManifest,
+  getItem,
+  getItemsBySlug,
+  listItems,
+  searchItems,
+  getItemContent,
+  fetchItemFile,
+  getItemSourcePath,
+  fetchItemToDestination,
+  CODING_AGENTS,
+  ALL_AGENTS,
+  getAgentConfig,
+  getContentPath,
+  getSettingsPath,
+  getMcpConfigPath,
+  getAgentPath,
+  detectInstalledAgents,
+  detectProjectAgents,
+  isAgentInstalled,
+  parseAgentsArgStrict,
+  p,
+  isInteractive,
+  brand,
+  printLogo,
+  selectSkill,
+  selectAgents,
+  selectScope,
+  selectMethod,
+  confirm2 as confirm,
+  intro2 as intro,
+  outro2 as outro,
+  step,
+  info,
+  success,
+  warn,
+  error,
+  installSkill,
+  uninstallSkill,
+  getInstalledSkills,
+  skillHandler
+};