@musher-dev/musher-sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,2056 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/frontmatter.ts
+function parseFrontmatter(text) {
+  const match = FRONTMATTER_RE.exec(text);
+  if (!match) {
+    return { body: text };
+  }
+  const raw = match[1];
+  const body = match[2];
+  let name;
+  let description;
+  for (const line of raw.split("\n")) {
+    const fm = FIELD_RE.exec(line.trim());
+    if (!fm) {
+      continue;
+    }
+    const value = stripQuotes(fm[2].trim());
+    if (fm[1] === "name") {
+      name = value;
+    } else if (fm[1] === "description") {
+      description = value;
+    }
+  }
+  return { name, description, body };
+}
+function stripQuotes(s) {
+  if (s.length >= 2) {
+    const first = s[0];
+    const last = s[s.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return s.slice(1, -1);
+    }
+  }
+  return s;
+}
+function extractDescription(skill) {
+  const def = skill.definition();
+  if (!def) {
+    return `Skill: ${skill.name}`;
+  }
+  const text = def.text();
+  const fm = parseFrontmatter(text);
+  if (fm.description) {
+    return fm.description;
+  }
+  return text.slice(0, 200).replace(/\n/g, " ").trim() || `Skill: ${skill.name}`;
+}
+var FRONTMATTER_RE, FIELD_RE;
+var init_frontmatter = __esm({
+  "src/frontmatter.ts"() {
+    "use strict";
+    FRONTMATTER_RE = /^---[ \t]*\n([\s\S]*?)---[ \t]*\n?([\s\S]*)$/;
+    FIELD_RE = /^(name|description)\s*:\s*(.+)$/;
+  }
+});
+
+// src/adapters/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  exportOpenAIInlineSkill: () => exportOpenAIInlineSkill,
+  exportOpenAILocalSkill: () => exportOpenAILocalSkill
+});
+async function exportOpenAILocalSkill(skill, targetDir) {
+  const { mkdir: mkdir6, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join7, resolve: resolve5, dirname: dirname5 } = await import("path");
+  const skillDir = resolve5(targetDir, skill.name);
+  await mkdir6(skillDir, { recursive: true });
+  for (const fh of skill.files()) {
+    const relativePath = fh.logicalPath.replace(SKILL_PREFIX_RE, "");
+    const filePath = join7(skillDir, relativePath);
+    await mkdir6(dirname5(filePath), { recursive: true });
+    await writeFile6(filePath, fh.bytes());
+  }
+  const description = extractDescription(skill);
+  return { name: skill.name, description, path: skillDir };
+}
+function exportOpenAIInlineSkill(skill) {
+  const description = extractDescription(skill);
+  const zipBuffer = buildStoreZip(skill);
+  const data = zipBuffer.toString("base64");
+  return {
+    type: "inline",
+    name: skill.name,
+    description,
+    source: { type: "base64", mediaType: "application/zip", data }
+  };
+}
+function buildStoreZip(skill) {
+  const files = skill.files().map((fh) => {
+    const relativePath = fh.logicalPath.replace(SKILL_PREFIX_RE, "");
+    const name = `${skill.name}/${relativePath}`;
+    return { name, data: Buffer.from(fh.bytes()) };
+  });
+  const parts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const file of files) {
+    const nameBuffer = Buffer.from(file.name, "utf-8");
+    const local = Buffer.alloc(30 + nameBuffer.length);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(crc32(file.data), 14);
+    local.writeUInt32LE(file.data.length, 18);
+    local.writeUInt32LE(file.data.length, 22);
+    local.writeUInt16LE(nameBuffer.length, 26);
+    local.writeUInt16LE(0, 28);
+    nameBuffer.copy(local, 30);
+    const central = Buffer.alloc(46 + nameBuffer.length);
+    central.writeUInt32LE(33639248, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0, 8);
+    central.writeUInt16LE(0, 10);
+    central.writeUInt16LE(0, 12);
+    central.writeUInt16LE(0, 14);
+    central.writeUInt32LE(crc32(file.data), 16);
+    central.writeUInt32LE(file.data.length, 20);
+    central.writeUInt32LE(file.data.length, 24);
+    central.writeUInt16LE(nameBuffer.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    nameBuffer.copy(central, 46);
+    parts.push(local, file.data);
+    centralParts.push(central);
+    offset += local.length + file.data.length;
+  }
+  const centralDirOffset = offset;
+  let centralDirSize = 0;
+  for (const c of centralParts) {
+    centralDirSize += c.length;
+  }
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(101010256, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(files.length, 8);
+  eocd.writeUInt16LE(files.length, 10);
+  eocd.writeUInt32LE(centralDirSize, 12);
+  eocd.writeUInt32LE(centralDirOffset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...parts, ...centralParts, eocd]);
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i];
+    for (let j = 0; j < 8; j++) {
+      crc = crc & 1 ? crc >>> 1 ^ 3988292384 : crc >>> 1;
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var SKILL_PREFIX_RE;
+var init_openai = __esm({
+  "src/adapters/openai.ts"() {
+    "use strict";
+    init_frontmatter();
+    SKILL_PREFIX_RE = /^skills\/[^/]+\//;
+  }
+});
+
+// src/adapters/claude.ts
+var claude_exports = {};
+__export(claude_exports, {
+  exportClaudePlugin: () => exportClaudePlugin,
+  installClaudeSkills: () => installClaudeSkills
+});
+import { mkdir, writeFile } from "fs/promises";
+import { join, resolve } from "path";
+async function exportClaudePlugin(source, opts) {
+  const bundle = "bundle" in source ? source.bundle : source;
+  const name = opts.name ?? bundle.ref.slug;
+  const pluginDir = resolve(opts.targetDir, name);
+  await mkdir(pluginDir, { recursive: true });
+  const files = source.files();
+  for (const fh of files) {
+    const filePath = join(pluginDir, fh.logicalPath);
+    await mkdir(join(filePath, ".."), { recursive: true });
+    await writeFile(filePath, fh.bytes());
+  }
+  const metaDir = join(pluginDir, ".claude-plugin");
+  await mkdir(metaDir, { recursive: true });
+  const manifest = {
+    name,
+    description: opts.description ?? "",
+    version: bundle.version,
+    files: files.map((f) => f.logicalPath)
+  };
+  await writeFile(join(metaDir, "plugin.json"), JSON.stringify(manifest, null, 2));
+  return pluginDir;
+}
+async function installClaudeSkills(bundle, dir, opts) {
+  const source = "bundle" in bundle ? bundle.bundle : bundle;
+  const skillsDir = resolve(dir, ".claude", "skills");
+  const prefix = opts?.prefix ?? "";
+  const written = [];
+  const skills = "skills" in bundle && typeof bundle.skills === "function" ? bundle.skills() : source.skills();
+  for (const skill of skills) {
+    const skillDir = join(skillsDir, prefix, skill.name);
+    await mkdir(skillDir, { recursive: true });
+    for (const fh of skill.files()) {
+      const relativePath = fh.logicalPath.replace(SKILL_PREFIX_RE2, "");
+      const filePath = join(skillDir, relativePath);
+      await mkdir(join(filePath, ".."), { recursive: true });
+      await writeFile(filePath, fh.bytes());
+      written.push(filePath);
+    }
+  }
+  return written;
+}
+var SKILL_PREFIX_RE2;
+var init_claude = __esm({
+  "src/adapters/claude.ts"() {
+    "use strict";
+    SKILL_PREFIX_RE2 = /^skills\/[^/]+\//;
+  }
+});
+
+// src/adapters/vscode.ts
+var vscode_exports = {};
+__export(vscode_exports, {
+  installVSCodeSkills: () => installVSCodeSkills
+});
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+async function installVSCodeSkills(source, dir, opts) {
+  const bundle = "bundle" in source ? source.bundle : source;
+  const subdir = opts?.subdir ?? ".agents/skills";
+  const skillsDir = resolve2(dir, subdir);
+  const written = [];
+  const skills = "skills" in source && typeof source.skills === "function" ? source.skills() : bundle.skills();
+  for (const skill of skills) {
+    const skillDir = join2(skillsDir, skill.name);
+    await mkdir2(skillDir, { recursive: true });
+    for (const fh of skill.files()) {
+      const relativePath = fh.logicalPath.replace(SKILL_PREFIX_RE3, "");
+      const filePath = join2(skillDir, relativePath);
+      await mkdir2(dirname(filePath), { recursive: true });
+      await writeFile2(filePath, fh.bytes());
+      written.push(filePath);
+    }
+  }
+  return written;
+}
+var SKILL_PREFIX_RE3;
+var init_vscode = __esm({
+  "src/adapters/vscode.ts"() {
+    "use strict";
+    SKILL_PREFIX_RE3 = /^skills\/[^/]+\//;
+  }
+});
+
+// src/client.ts
+import { createHash as createHash3 } from "crypto";
+
+// src/bundle.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+
+// src/handles/agent-spec-handle.ts
+var AgentSpecHandle = class {
+  name;
+  _file;
+  constructor(name, file) {
+    this.name = name;
+    this._file = file;
+  }
+  /** All files belonging to this agent spec (single file). */
+  files() {
+    return [this._file];
+  }
+  /** The agent spec content as text. */
+  content() {
+    return this._file.text();
+  }
+  /** The underlying file handle. */
+  file() {
+    return this._file;
+  }
+};
+
+// src/handles/file-handle.ts
+var FileHandle = class {
+  logicalPath;
+  assetType;
+  sha256;
+  mediaType;
+  sizeBytes;
+  _content;
+  constructor(logicalPath, assetType, sha256, sizeBytes, content, mediaType) {
+    this.logicalPath = logicalPath;
+    this.assetType = assetType;
+    this.sha256 = sha256;
+    this.sizeBytes = sizeBytes;
+    this._content = content;
+    this.mediaType = mediaType;
+  }
+  /** Return content as a UTF-8 string. */
+  text() {
+    return this._content.toString("utf-8");
+  }
+  /** Return content as a Uint8Array. */
+  bytes() {
+    return new Uint8Array(this._content.buffer, this._content.byteOffset, this._content.byteLength);
+  }
+  /** Return content as a ReadableStream. */
+  stream() {
+    const bytes = this.bytes();
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(bytes);
+        controller.close();
+      }
+    });
+  }
+};
+
+// src/handles/prompt-handle.ts
+var PromptHandle = class {
+  name;
+  _file;
+  constructor(name, file) {
+    this.name = name;
+    this._file = file;
+  }
+  /** All files belonging to this prompt (single file). */
+  files() {
+    return [this._file];
+  }
+  /** The prompt content as text. */
+  content() {
+    return this._file.text();
+  }
+  /** The underlying file handle. */
+  file() {
+    return this._file;
+  }
+};
+
+// src/handles/skill-handle.ts
+init_frontmatter();
+var SkillHandle = class {
+  name;
+  _files;
+  constructor(name, files) {
+    this.name = name;
+    this._files = files;
+  }
+  /** All files belonging to this skill. */
+  files() {
+    return [...this._files];
+  }
+  /** The SKILL.md definition file, if present. */
+  definition() {
+    return this._files.find(
+      (f) => f.logicalPath.toLowerCase().endsWith("/skill.md") || f.logicalPath.toLowerCase() === "skill.md"
+    );
+  }
+  /** Parsed frontmatter from SKILL.md, if present. */
+  metadata() {
+    const def = this.definition();
+    if (!def) {
+      return void 0;
+    }
+    return parseFrontmatter(def.text());
+  }
+  /** Export as an OpenAI local skill directory. */
+  async exportOpenAILocal(targetDir) {
+    const { exportOpenAILocalSkill: exportOpenAILocalSkill2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+    return exportOpenAILocalSkill2(this, targetDir);
+  }
+  /** Export as an OpenAI inline base64 ZIP skill. */
+  async exportOpenAIInline() {
+    const { exportOpenAIInlineSkill: exportOpenAIInlineSkill2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+    return exportOpenAIInlineSkill2(this);
+  }
+};
+
+// src/handles/toolset-handle.ts
+var ToolsetHandle = class {
+  name;
+  _file;
+  constructor(name, file) {
+    this.name = name;
+    this._file = file;
+  }
+  /** All files belonging to this toolset (single file). */
+  files() {
+    return [this._file];
+  }
+  /** The toolset content as text. */
+  content() {
+    return this._file.text();
+  }
+  /** The underlying file handle. */
+  file() {
+    return this._file;
+  }
+};
+
+// src/errors.ts
+var MushError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MushError";
+  }
+};
+var ApiError = class extends MushError {
+  status;
+  problem;
+  constructor(problem, options) {
+    super(problem.detail, options);
+    this.name = "ApiError";
+    this.status = problem.status;
+    this.problem = problem;
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(problem, options) {
+    super(problem, options);
+    this.name = "NotFoundError";
+  }
+};
+var AuthenticationError = class extends ApiError {
+  constructor(problem, options) {
+    super(problem, options);
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends ApiError {
+  constructor(problem, options) {
+    super(problem, options);
+    this.name = "ForbiddenError";
+  }
+};
+var ValidationError = class extends ApiError {
+  errors;
+  constructor(problem, options) {
+    super(problem, options);
+    this.name = "ValidationError";
+    this.errors = problem.errors;
+  }
+};
+var RateLimitError = class extends ApiError {
+  retryAfter;
+  constructor(problem, retryAfter, options) {
+    super(problem, options);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NetworkError = class extends MushError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends NetworkError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TimeoutError";
+  }
+};
+var CacheError = class extends MushError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CacheError";
+  }
+};
+var IntegrityError = class extends CacheError {
+  constructor(expected, actual, options) {
+    super(`SHA256 mismatch: expected ${expected}, got ${actual}`, options);
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "IntegrityError";
+  }
+};
+var SchemaError = class extends MushError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SchemaError";
+  }
+};
+
+// src/ref.ts
+var REF_PATTERN = /^([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(?::(.+)|@sha256:([a-fA-F0-9]+))?$/;
+var BundleRef = class _BundleRef {
+  namespace;
+  slug;
+  version;
+  digest;
+  constructor(namespace, slug, version, digest) {
+    this.namespace = namespace;
+    this.slug = slug;
+    this.version = version;
+    this.digest = digest;
+  }
+  /** Parse a ref string into a BundleRef. */
+  static parse(ref) {
+    const match = ref.match(REF_PATTERN);
+    if (!match) {
+      throw new MushError(
+        `Invalid bundle ref "${ref}": expected "namespace/slug", "namespace/slug:version", or "namespace/slug@sha256:digest"`
+      );
+    }
+    const [, namespace, slug, version, digest] = match;
+    return new _BundleRef(namespace, slug, version, digest);
+  }
+  /** Return the base ref without version or digest: "namespace/slug". */
+  toBaseRef() {
+    return `${this.namespace}/${this.slug}`;
+  }
+  /** Return the full ref string. */
+  toString() {
+    if (this.digest) {
+      return `${this.namespace}/${this.slug}@sha256:${this.digest}`;
+    }
+    if (this.version) {
+      return `${this.namespace}/${this.slug}:${this.version}`;
+    }
+    return `${this.namespace}/${this.slug}`;
+  }
+};
+
+// src/selection.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+var Selection = class {
+  _bundle;
+  _filter;
+  constructor(bundle, filter) {
+    this._bundle = bundle;
+    this._filter = filter;
+  }
+  /** The underlying bundle. */
+  get bundle() {
+    return this._bundle;
+  }
+  files() {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    const addFile = (fh) => {
+      if (!seen.has(fh.logicalPath)) {
+        seen.add(fh.logicalPath);
+        result.push(fh);
+      }
+    };
+    if (this._filter.skills) {
+      for (const name of this._filter.skills) {
+        const skill = this._bundle.skills().find((s) => s.name === name);
+        if (skill) {
+          for (const f of skill.files()) {
+            addFile(f);
+          }
+        }
+      }
+    }
+    if (this._filter.prompts) {
+      for (const name of this._filter.prompts) {
+        const prompt = this._bundle.prompts().find((p) => p.name === name);
+        if (prompt) {
+          for (const f of prompt.files()) {
+            addFile(f);
+          }
+        }
+      }
+    }
+    if (this._filter.toolsets) {
+      for (const name of this._filter.toolsets) {
+        const toolset = this._bundle.toolsets().find((t) => t.name === name);
+        if (toolset) {
+          for (const f of toolset.files()) {
+            addFile(f);
+          }
+        }
+      }
+    }
+    if (this._filter.agentSpecs) {
+      for (const name of this._filter.agentSpecs) {
+        const spec = this._bundle.agentSpecs().find((a) => a.name === name);
+        if (spec) {
+          for (const f of spec.files()) {
+            addFile(f);
+          }
+        }
+      }
+    }
+    if (this._filter.paths) {
+      for (const path of this._filter.paths) {
+        const fh = this._bundle.file(path);
+        if (fh) {
+          addFile(fh);
+        }
+      }
+    }
+    return result;
+  }
+  skills() {
+    const names = this._filter.skills;
+    if (!names) {
+      return [];
+    }
+    return this._bundle.skills().filter((s) => names.includes(s.name));
+  }
+  prompts() {
+    const names = this._filter.prompts;
+    if (!names) {
+      return [];
+    }
+    return this._bundle.prompts().filter((p) => names.includes(p.name));
+  }
+  toolsets() {
+    const names = this._filter.toolsets;
+    if (!names) {
+      return [];
+    }
+    return this._bundle.toolsets().filter((t) => names.includes(t.name));
+  }
+  agentSpecs() {
+    const names = this._filter.agentSpecs;
+    if (!names) {
+      return [];
+    }
+    return this._bundle.agentSpecs().filter((a) => names.includes(a.name));
+  }
+  /** Write selected files to targetDir preserving logical paths. */
+  async materialize(targetDir) {
+    const written = [];
+    for (const fh of this.files()) {
+      const absPath = resolve3(join3(targetDir, fh.logicalPath));
+      await mkdir3(dirname2(absPath), { recursive: true });
+      await writeFile3(absPath, fh.bytes());
+      written.push(absPath);
+    }
+    return written;
+  }
+  // -- Export adapter convenience methods --
+  async exportClaudePlugin(opts) {
+    const { exportClaudePlugin: exportClaudePlugin2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+    return exportClaudePlugin2(this, opts);
+  }
+  async installClaudeSkills(dir, opts) {
+    const { installClaudeSkills: installClaudeSkills2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+    return installClaudeSkills2(this, dir, opts);
+  }
+  async installVSCodeSkills(dir, opts) {
+    const { installVSCodeSkills: installVSCodeSkills2 } = await Promise.resolve().then(() => (init_vscode(), vscode_exports));
+    return installVSCodeSkills2(this, dir, opts);
+  }
+};
+
+// src/bundle.ts
+var Bundle = class {
+  ref;
+  version;
+  metadata;
+  _files;
+  _skills;
+  _prompts;
+  _toolsets;
+  _agentSpecs;
+  constructor(metadata, contents) {
+    this.metadata = metadata;
+    this.version = metadata.version;
+    this.ref = BundleRef.parse(metadata.ref);
+    this._files = /* @__PURE__ */ new Map();
+    if (metadata.manifest?.layers) {
+      for (const layer of metadata.manifest.layers) {
+        const buf = contents.get(layer.logicalPath);
+        if (buf) {
+          const fh = new FileHandle(
+            layer.logicalPath,
+            layer.assetType,
+            layer.contentSha256,
+            layer.sizeBytes,
+            buf,
+            layer.mediaType ?? void 0
+          );
+          this._files.set(layer.logicalPath, fh);
+        }
+      }
+    }
+    this._skills = /* @__PURE__ */ new Map();
+    this._prompts = /* @__PURE__ */ new Map();
+    this._toolsets = /* @__PURE__ */ new Map();
+    this._agentSpecs = /* @__PURE__ */ new Map();
+    const skillGroups = /* @__PURE__ */ new Map();
+    for (const fh of this._files.values()) {
+      switch (fh.assetType) {
+        case "skill": {
+          const skillName = extractSkillName(fh.logicalPath);
+          if (skillName) {
+            let group = skillGroups.get(skillName);
+            if (!group) {
+              group = [];
+              skillGroups.set(skillName, group);
+            }
+            group.push(fh);
+          }
+          break;
+        }
+        case "prompt": {
+          const name = baseFileName(fh.logicalPath);
+          this._prompts.set(name, new PromptHandle(name, fh));
+          break;
+        }
+        case "tool_config": {
+          const name = baseFileName(fh.logicalPath);
+          this._toolsets.set(name, new ToolsetHandle(name, fh));
+          break;
+        }
+        case "agent_definition": {
+          const name = baseFileName(fh.logicalPath);
+          this._agentSpecs.set(name, new AgentSpecHandle(name, fh));
+          break;
+        }
+      }
+    }
+    for (const [name, files] of skillGroups) {
+      this._skills.set(name, new SkillHandle(name, files));
+    }
+  }
+  // -- File access --
+  file(path) {
+    return this._files.get(path);
+  }
+  files() {
+    return [...this._files.values()];
+  }
+  // -- Domain handles --
+  skills() {
+    return [...this._skills.values()];
+  }
+  skill(name) {
+    const h = this._skills.get(name);
+    if (!h) {
+      throw new Error(`Skill "${name}" not found in bundle`);
+    }
+    return h;
+  }
+  prompts() {
+    return [...this._prompts.values()];
+  }
+  prompt(name) {
+    const h = this._prompts.get(name);
+    if (!h) {
+      throw new Error(`Prompt "${name}" not found in bundle`);
+    }
+    return h;
+  }
+  toolsets() {
+    return [...this._toolsets.values()];
+  }
+  toolset(name) {
+    const h = this._toolsets.get(name);
+    if (!h) {
+      throw new Error(`Toolset "${name}" not found in bundle`);
+    }
+    return h;
+  }
+  agentSpecs() {
+    return [...this._agentSpecs.values()];
+  }
+  agentSpec(name) {
+    const h = this._agentSpecs.get(name);
+    if (!h) {
+      throw new Error(`AgentSpec "${name}" not found in bundle`);
+    }
+    return h;
+  }
+  // -- Filtering --
+  select(filter) {
+    return new Selection(this, filter);
+  }
+  // -- Integrity --
+  verify() {
+    const errors = [];
+    for (const fh of this._files.values()) {
+      const actual = createHash("sha256").update(fh.bytes()).digest("hex");
+      if (actual !== fh.sha256) {
+        errors.push({ path: fh.logicalPath, expected: fh.sha256, actual });
+      }
+    }
+    return { ok: errors.length === 0, errors };
+  }
+  // -- Lockfile --
+  async writeLockfile(path) {
+    const lock = {
+      ref: this.ref.toString(),
+      version: this.version,
+      files: [...this._files.values()].map((f) => ({
+        logicalPath: f.logicalPath,
+        sha256: f.sha256,
+        sizeBytes: f.sizeBytes
+      }))
+    };
+    await mkdir4(dirname3(path), { recursive: true });
+    await writeFile4(path, JSON.stringify(lock, null, 2));
+  }
+  // -- Export adapter convenience methods --
+  async exportClaudePlugin(opts) {
+    const { exportClaudePlugin: exportClaudePlugin2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+    return exportClaudePlugin2(this, opts);
+  }
+  async installClaudeSkills(dir, opts) {
+    const { installClaudeSkills: installClaudeSkills2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+    return installClaudeSkills2(this, dir, opts);
+  }
+  async installVSCodeSkills(dir, opts) {
+    const { installVSCodeSkills: installVSCodeSkills2 } = await Promise.resolve().then(() => (init_vscode(), vscode_exports));
+    return installVSCodeSkills2(this, dir, opts);
+  }
+  // -- Deprecated compat --
+  /** @deprecated Use `file(path)` instead. */
+  getAsset(path) {
+    const fh = this._files.get(path);
+    if (!fh) {
+      return void 0;
+    }
+    return {
+      logicalPath: fh.logicalPath,
+      assetType: fh.assetType,
+      content: fh.text(),
+      sha256: fh.sha256,
+      mediaType: fh.mediaType
+    };
+  }
+  /** @deprecated Use `files().filter(...)` instead. */
+  getAssetsByType(type) {
+    return [...this._files.values()].filter((fh) => fh.assetType === type).map((fh) => ({
+      logicalPath: fh.logicalPath,
+      assetType: fh.assetType,
+      content: fh.text(),
+      sha256: fh.sha256,
+      mediaType: fh.mediaType
+    }));
+  }
+};
+function extractSkillName(logicalPath) {
+  if (!logicalPath.startsWith("skills/")) {
+    return void 0;
+  }
+  const rest = logicalPath.slice("skills/".length);
+  const slashIdx = rest.indexOf("/");
+  if (slashIdx === -1) {
+    return void 0;
+  }
+  const name = rest.slice(0, slashIdx);
+  return name || void 0;
+}
+function baseFileName(logicalPath) {
+  const parts = logicalPath.split("/");
+  const last = parts[parts.length - 1] ?? logicalPath;
+  const dotIdx = last.lastIndexOf(".");
+  return dotIdx > 0 ? last.slice(0, dotIdx) : last;
+}
+
+// src/cache.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { mkdir as mkdir5, readFile, readdir, rename, rm, stat, unlink, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname4, join as join4 } from "path";
+var JSON_EXT_RE = /\.json$/;
+var CACHEDIR_TAG_CONTENT = `Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by musher.
+# For information, see https://bford.info/cachedir/spec.html
+`;
+var BundleCache = class {
+  constructor(cacheDir, registryUrl, manifestTtlSeconds, refTtlSeconds) {
+    this.cacheDir = cacheDir;
+    this.manifestTtlSeconds = manifestTtlSeconds;
+    this.refTtlSeconds = refTtlSeconds;
+    this.hostId = computeHostId(registryUrl);
+  }
+  hostId;
+  // -- Blob storage -------------------------------------------------------------
+  blobPath(digest) {
+    const prefix = digest.slice(0, 2);
+    return join4(this.cacheDir, "blobs", "sha256", prefix, digest);
+  }
+  async writeBlob(content) {
+    const digest = createHash2("sha256").update(content).digest("hex");
+    const target = this.blobPath(digest);
+    if (existsSync(target)) {
+      return digest;
+    }
+    await this.atomicWrite(target, content);
+    return digest;
+  }
+  // -- Manifest storage ---------------------------------------------------------
+  manifestDir(namespace, slug) {
+    return join4(this.cacheDir, "manifests", this.hostId, namespace, slug);
+  }
+  manifestPath(namespace, slug, version) {
+    return join4(this.manifestDir(namespace, slug), `${version}.json`);
+  }
+  metaPath(namespace, slug, version) {
+    return join4(this.manifestDir(namespace, slug), `${version}.meta.json`);
+  }
+  // -- Ref storage --------------------------------------------------------------
+  refPath(namespace, slug, ref) {
+    return join4(this.cacheDir, "refs", this.hostId, namespace, slug, `${ref}.json`);
+  }
+  /** Cache a ref → version mapping with TTL. */
+  async cacheRef(namespace, slug, ref, version) {
+    const entry = {
+      version,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ttlSeconds: this.refTtlSeconds
+    };
+    const target = this.refPath(namespace, slug, ref);
+    await this.atomicWrite(target, Buffer.from(JSON.stringify(entry, null, 2)));
+  }
+  /** Resolve a cached ref → version if still fresh. Returns null if expired or missing. */
+  async resolveRef(namespace, slug, ref) {
+    try {
+      const raw = await readFile(this.refPath(namespace, slug, ref), "utf-8");
+      const entry = JSON.parse(raw);
+      const fetchedAt = new Date(entry.fetchedAt).getTime();
+      const ttl = (entry.ttlSeconds ?? this.refTtlSeconds) * 1e3;
+      if (Date.now() - fetchedAt < ttl) {
+        return entry.version;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  // -- Freshness ----------------------------------------------------------------
+  /** Check if a cached manifest is still fresh. */
+  async isFresh(namespace, slug, version) {
+    try {
+      const raw = await readFile(this.metaPath(namespace, slug, version), "utf-8");
+      const meta = JSON.parse(raw);
+      const fetchedAt = new Date(meta.fetchedAt).getTime();
+      const ttl = (meta.ttlSeconds ?? this.manifestTtlSeconds) * 1e3;
+      return Date.now() - fetchedAt < ttl;
+    } catch {
+      return false;
+    }
+  }
+  /** Load only the manifest JSON (no blob content). Returns null if not cached. */
+  async loadManifest(namespace, slug, version) {
+    const mPath = this.manifestPath(namespace, slug, version);
+    if (!existsSync(mPath)) {
+      return null;
+    }
+    try {
+      const raw = await readFile(mPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  // -- Write --------------------------------------------------------------------
+  /** Write only the manifest and metadata to the cache (no blobs). */
+  async writeManifest(manifest) {
+    try {
+      await this.ensureCacheDirTag();
+      const mPath = this.manifestPath(manifest.namespace, manifest.slug, manifest.version);
+      await this.atomicWrite(mPath, Buffer.from(JSON.stringify(manifest, null, 2)));
+      const meta = {
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ttlSeconds: this.manifestTtlSeconds,
+        ociDigest: manifest.ociDigest ?? void 0
+      };
+      const metPath = this.metaPath(manifest.namespace, manifest.slug, manifest.version);
+      await this.atomicWrite(metPath, Buffer.from(JSON.stringify(meta, null, 2)));
+    } catch (error) {
+      throw new CacheError(
+        `Failed to write manifest cache: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  /** Write a resolved bundle and its assets to the cache. */
+  async write(manifest, assets) {
+    try {
+      await this.ensureCacheDirTag();
+      for (const [, content] of assets) {
+        const buf = typeof content === "string" ? Buffer.from(content, "utf-8") : content;
+        await this.writeBlob(buf);
+      }
+      await this.writeManifest(manifest);
+      return {
+        ref: manifest.ref,
+        version: manifest.version,
+        cacheDir: this.manifestDir(manifest.namespace, manifest.slug),
+        manifest
+      };
+    } catch (error) {
+      throw new CacheError(
+        `Failed to write cache: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  // -- Load ---------------------------------------------------------------------
+  /** Load a cached bundle from disk, verifying SHA256 integrity. Returns a Bundle. */
+  async load(namespace, slug, version) {
+    const mPath = this.manifestPath(namespace, slug, version);
+    if (!existsSync(mPath)) {
+      return null;
+    }
+    try {
+      const raw = await readFile(mPath, "utf-8");
+      const manifest = JSON.parse(raw);
+      const contents = /* @__PURE__ */ new Map();
+      if (manifest.manifest?.layers) {
+        for (const layer of manifest.manifest.layers) {
+          const buf = await readFile(this.blobPath(layer.contentSha256));
+          const hash = createHash2("sha256").update(buf).digest("hex");
+          if (hash !== layer.contentSha256) {
+            throw new IntegrityError(layer.contentSha256, hash);
+          }
+          contents.set(layer.logicalPath, buf);
+        }
+      }
+      return new Bundle(manifest, contents);
+    } catch (error) {
+      if (error instanceof IntegrityError) {
+        throw error;
+      }
+      throw new CacheError(
+        `Failed to load cache: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  // -- Cleanup ------------------------------------------------------------------
+  /** Remove expired cache entries and garbage-collect unreferenced blobs. */
+  async clean() {
+    try {
+      const referencedDigests = /* @__PURE__ */ new Set();
+      await this.cleanManifests(referencedDigests);
+      await this.cleanRefs();
+      await this.gcBlobs(referencedDigests);
+      await this.removeLegacy();
+    } catch (error) {
+      throw new CacheError(
+        `Failed to clean cache: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  /** Remove all cached data. */
+  async purge() {
+    try {
+      const dirs = ["manifests", "refs", "blobs", "temp", "bundles"];
+      for (const dir of dirs) {
+        const p = join4(this.cacheDir, dir);
+        if (existsSync(p)) {
+          await rm(p, { recursive: true, force: true });
+        }
+      }
+    } catch (error) {
+      throw new CacheError(
+        `Failed to purge cache: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  // -- Internals ----------------------------------------------------------------
+  /** Atomic write via temp file + rename. */
+  async atomicWrite(targetPath, data) {
+    const tempDir = join4(this.cacheDir, "temp");
+    await mkdir5(tempDir, { recursive: true });
+    const tempPath = join4(tempDir, `${randomUUID()}.tmp`);
+    try {
+      await writeFile5(tempPath, data);
+      await mkdir5(dirname4(targetPath), { recursive: true });
+      try {
+        await rename(tempPath, targetPath);
+      } catch {
+        try {
+          await unlink(targetPath);
+        } catch {
+        }
+        await rename(tempPath, targetPath);
+      }
+    } finally {
+      try {
+        await unlink(tempPath);
+      } catch {
+      }
+    }
+  }
+  /** Write CACHEDIR.TAG if it doesn't exist. */
+  async ensureCacheDirTag() {
+    const tagPath = join4(this.cacheDir, "CACHEDIR.TAG");
+    if (!existsSync(tagPath)) {
+      await mkdir5(this.cacheDir, { recursive: true });
+      await writeFile5(tagPath, CACHEDIR_TAG_CONTENT);
+    }
+  }
+  /** Walk manifests, remove expired, collect digests from surviving ones. */
+  async cleanManifests(referencedDigests) {
+    const manifestsRoot = join4(this.cacheDir, "manifests");
+    if (!existsSync(manifestsRoot)) {
+      return;
+    }
+    for (const hostId of await safeReaddir(manifestsRoot)) {
+      const hostDir = join4(manifestsRoot, hostId);
+      if (!await isDir(hostDir)) {
+        continue;
+      }
+      for (const ns of await safeReaddir(hostDir)) {
+        const nsDir = join4(hostDir, ns);
+        if (!await isDir(nsDir)) {
+          continue;
+        }
+        for (const slug of await safeReaddir(nsDir)) {
+          const slugDir = join4(nsDir, slug);
+          if (!await isDir(slugDir)) {
+            continue;
+          }
+          for (const file of await safeReaddir(slugDir)) {
+            if (!file.endsWith(".json") || file.endsWith(".meta.json")) {
+              continue;
+            }
+            const version = file.replace(JSON_EXT_RE, "");
+            const fresh = await this.isFresh(ns, slug, version);
+            if (fresh) {
+              await this.collectDigests(join4(slugDir, file), referencedDigests);
+            } else {
+              await safeRm(join4(slugDir, file));
+              await safeRm(join4(slugDir, `${version}.meta.json`));
+            }
+          }
+        }
+      }
+    }
+  }
+  /** Collect blob digests referenced by a manifest file. */
+  async collectDigests(manifestFile, digests) {
+    try {
+      const raw = await readFile(manifestFile, "utf-8");
+      const manifest = JSON.parse(raw);
+      if (manifest.manifest?.layers) {
+        for (const layer of manifest.manifest.layers) {
+          digests.add(layer.contentSha256);
+        }
+      }
+    } catch {
+    }
+  }
+  /** Walk refs and remove expired entries. */
+  async cleanRefs() {
+    const refsRoot = join4(this.cacheDir, "refs");
+    if (!existsSync(refsRoot)) {
+      return;
+    }
+    for (const hostId of await safeReaddir(refsRoot)) {
+      const hostDir = join4(refsRoot, hostId);
+      if (!await isDir(hostDir)) {
+        continue;
+      }
+      for (const ns of await safeReaddir(hostDir)) {
+        const nsDir = join4(hostDir, ns);
+        if (!await isDir(nsDir)) {
+          continue;
+        }
+        for (const slug of await safeReaddir(nsDir)) {
+          const slugDir = join4(nsDir, slug);
+          if (!await isDir(slugDir)) {
+            continue;
+          }
+          for (const file of await safeReaddir(slugDir)) {
+            if (!file.endsWith(".json")) {
+              continue;
+            }
+            const ref = file.replace(JSON_EXT_RE, "");
+            const version = await this.resolveRef(ns, slug, ref);
+            if (version === null) {
+              await safeRm(join4(slugDir, file));
+            }
+          }
+        }
+      }
+    }
+  }
+  /** Remove blobs not referenced by any surviving manifest. */
+  async gcBlobs(referencedDigests) {
+    const blobsRoot = join4(this.cacheDir, "blobs", "sha256");
+    if (!existsSync(blobsRoot)) {
+      return;
+    }
+    for (const prefix of await safeReaddir(blobsRoot)) {
+      const prefixDir = join4(blobsRoot, prefix);
+      if (!await isDir(prefixDir)) {
+        continue;
+      }
+      for (const digest of await safeReaddir(prefixDir)) {
+        if (!referencedDigests.has(digest)) {
+          await safeRm(join4(prefixDir, digest));
+        }
+      }
+    }
+  }
+  /** Remove legacy bundles/ directory if present. */
+  async removeLegacy() {
+    const legacyDir = join4(this.cacheDir, "bundles");
+    if (existsSync(legacyDir)) {
+      await rm(legacyDir, { recursive: true, force: true });
+    }
+  }
+};
+function computeHostId(registryUrl) {
+  try {
+    const url = new URL(registryUrl);
+    return url.host.replace(/[:/]/g, "_");
+  } catch {
+    return registryUrl.replace(/[:/]/g, "_");
+  }
+}
+async function isDir(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function safeReaddir(path) {
+  try {
+    return await readdir(path);
+  } catch {
+    return [];
+  }
+}
+async function safeRm(path) {
+  try {
+    await unlink(path);
+  } catch {
+  }
+}
+
+// src/config.ts
+import { readFileSync, statSync } from "fs";
+import { join as join6 } from "path";
+
+// src/keyring.ts
+import { execFileSync } from "child_process";
+var ACCOUNT = "api-key";
+function serviceName(host) {
+  return `musher/${host}`;
+}
+function tryKeyringLookup(service) {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      const result = execFileSync(
+        "security",
+        ["find-generic-password", "-s", service, "-a", ACCOUNT, "-w"],
+        {
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 5e3
+        }
+      );
+      return result.toString("utf-8").trim() || void 0;
+    }
+    if (platform === "linux") {
+      const result = execFileSync(
+        "secret-tool",
+        ["lookup", "service", service, "username", ACCOUNT],
+        {
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 5e3
+        }
+      );
+      return result.toString("utf-8").trim() || void 0;
+    }
+    if (platform === "win32") {
+      const result = execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `$cred = Get-StoredCredential -Target '${service.replace(/'/g, "''")}'; if ($cred) { $cred.GetNetworkCredential().Password }`
+        ],
+        {
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 5e3
+        }
+      );
+      return result.toString("utf-8").trim() || void 0;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readKeyring(host = "api.musher.dev") {
+  return tryKeyringLookup(serviceName(host));
+}
+
+// src/paths.ts
+import { homedir, tmpdir } from "os";
+import { isAbsolute, join as join5 } from "path";
+var APP_NAME = "musher";
+function env(name) {
+  const value = process.env[name];
+  return value || void 0;
+}
+function absEnv(name) {
+  const value = env(name);
+  if (value && isAbsolute(value)) {
+    return value;
+  }
+  return void 0;
+}
+function resolveDir(envKey, subdir, platformDefault) {
+  const perDir = absEnv(envKey);
+  if (perDir) {
+    return perDir;
+  }
+  const umbrella = absEnv("MUSHER_HOME");
+  if (umbrella) {
+    return join5(umbrella, subdir);
+  }
+  return platformDefault();
+}
+function xdgDefault(xdgVar, fallbackSuffix) {
+  const xdg = absEnv(xdgVar);
+  if (xdg) {
+    return join5(xdg, APP_NAME);
+  }
+  return join5(homedir(), fallbackSuffix, APP_NAME);
+}
+function linuxDirs() {
+  return {
+    cache: resolveDir("MUSHER_CACHE_HOME", "cache", () => xdgDefault("XDG_CACHE_HOME", ".cache")),
+    config: resolveDir(
+      "MUSHER_CONFIG_HOME",
+      "config",
+      () => xdgDefault("XDG_CONFIG_HOME", ".config")
+    ),
+    data: resolveDir(
+      "MUSHER_DATA_HOME",
+      "data",
+      () => xdgDefault("XDG_DATA_HOME", join5(".local", "share"))
+    ),
+    state: resolveDir(
+      "MUSHER_STATE_HOME",
+      "state",
+      () => xdgDefault("XDG_STATE_HOME", join5(".local", "state"))
+    ),
+    runtime: resolveDir("MUSHER_RUNTIME_DIR", "runtime", () => {
+      const xdg = absEnv("XDG_RUNTIME_DIR");
+      if (xdg) {
+        return join5(xdg, APP_NAME);
+      }
+      return join5(tmpdir(), APP_NAME, "run");
+    })
+  };
+}
+function darwinDirs() {
+  const home = homedir();
+  const appSupport = join5(home, "Library", "Application Support", APP_NAME);
+  return {
+    cache: resolveDir(
+      "MUSHER_CACHE_HOME",
+      "cache",
+      () => join5(home, "Library", "Caches", APP_NAME)
+    ),
+    config: resolveDir("MUSHER_CONFIG_HOME", "config", () => join5(appSupport, "config")),
+    data: resolveDir("MUSHER_DATA_HOME", "data", () => join5(appSupport, "data")),
+    state: resolveDir("MUSHER_STATE_HOME", "state", () => join5(appSupport, "state")),
+    runtime: resolveDir("MUSHER_RUNTIME_DIR", "runtime", () => join5(tmpdir(), APP_NAME, "run"))
+  };
+}
+function win32Dirs() {
+  const localAppData = env("LOCALAPPDATA") ?? join5(homedir(), "AppData", "Local");
+  const base = join5(localAppData, APP_NAME);
+  return {
+    cache: resolveDir("MUSHER_CACHE_HOME", "cache", () => join5(base, "cache")),
+    config: resolveDir("MUSHER_CONFIG_HOME", "config", () => join5(base, "config")),
+    data: resolveDir("MUSHER_DATA_HOME", "data", () => join5(base, "data")),
+    state: resolveDir("MUSHER_STATE_HOME", "state", () => join5(base, "state")),
+    runtime: resolveDir("MUSHER_RUNTIME_DIR", "runtime", () => join5(tmpdir(), APP_NAME, "run"))
+  };
+}
+function resolveMusherDirs() {
+  switch (process.platform) {
+    case "darwin":
+      return darwinDirs();
+    case "win32":
+      return win32Dirs();
+    default:
+      return linuxDirs();
+  }
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.musher.dev";
+var DEFAULT_MANIFEST_TTL = 86400;
+var DEFAULT_REF_TTL = 300;
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_RETRIES = 3;
+function computeHostId2(host) {
+  return host.replace(/[:/]/g, "_");
+}
+function readApiKeyFile(dataDir, host = "api.musher.dev") {
+  try {
+    const dir = dataDir ?? resolveMusherDirs().data;
+    const filePath = join6(dir, "credentials", computeHostId2(host), "api-key");
+    const content = readFileSync(filePath, "utf-8").trim();
+    if (!content) {
+      return void 0;
+    }
+    if (process.platform !== "win32") {
+      const mode = statSync(filePath).mode;
+      if (mode & 63) {
+        process.emitWarning(
+          `Ignoring ${filePath}: file permissions are too open (must not be readable by group or others). Run: chmod 600 ${filePath}`,
+          "MusherSecurityWarning"
+        );
+        return void 0;
+      }
+    }
+    return content;
+  } catch {
+    return void 0;
+  }
+}
+function env2(name) {
+  const value = process.env[name];
+  return value || void 0;
+}
+function resolveConfig(config) {
+  const dirs = resolveMusherDirs();
+  const configDir = config?.configDir ?? dirs.config;
+  const baseUrl = config?.baseUrl ?? env2("MUSHER_API_URL") ?? DEFAULT_BASE_URL;
+  let keyringHost;
+  try {
+    keyringHost = new URL(baseUrl).host;
+  } catch {
+    keyringHost = "api.musher.dev";
+  }
+  return {
+    baseUrl,
+    apiKey: config?.apiKey ?? env2("MUSHER_API_KEY") ?? readKeyring(keyringHost) ?? readApiKeyFile(dirs.data, keyringHost),
+    cacheDir: config?.cacheDir ?? dirs.cache,
+    configDir,
+    manifestTtlSeconds: config?.manifestTtlSeconds ?? DEFAULT_MANIFEST_TTL,
+    refTtlSeconds: config?.refTtlSeconds ?? DEFAULT_REF_TTL,
+    timeout: config?.timeout ?? DEFAULT_TIMEOUT,
+    retries: config?.retries ?? DEFAULT_RETRIES
+  };
+}
+
+// src/http.ts
+var TRAILING_SLASH_RE = /\/$/;
+var HttpTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(method, path, schema, options) {
+    const url = this.buildUrl(path, options?.params);
+    const headers = this.buildHeaders();
+    let lastError;
+    for (let attempt = 0; attempt <= this.config.retries; attempt++) {
+      try {
+        const init = { method, headers };
+        if (options?.body) {
+          init.body = JSON.stringify(options.body);
+        }
+        const response = await this.fetchWithTimeout(url, init);
+        if (!response.ok) {
+          const error = await this.mapError(response);
+          if (response.status === 429 || response.status >= 500) {
+            lastError = error;
+            if (attempt < this.config.retries) {
+              await this.backoff(attempt, error);
+              continue;
+            }
+          }
+          throw error;
+        }
+        const json = await response.json();
+        return this.parse(schema, json);
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw error;
+        }
+        if (error instanceof SchemaError) {
+          throw error;
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.config.retries) {
+          await this.backoff(attempt);
+        }
+      }
+    }
+    throw lastError ?? new NetworkError("Request failed after retries");
+  }
+  buildUrl(path, params) {
+    const base = this.config.baseUrl.replace(TRAILING_SLASH_RE, "");
+    const url = new URL(`${base}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${this.config.timeout}ms`);
+      }
+      throw new NetworkError(error instanceof Error ? error.message : "Network request failed", {
+        cause: error instanceof Error ? error : void 0
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async mapError(response) {
+    let problem;
+    try {
+      const body = await response.json();
+      problem = {
+        type: body.type ?? "about:blank",
+        title: body.title ?? response.statusText,
+        status: response.status,
+        detail: body.detail ?? response.statusText,
+        instance: body.instance,
+        traceId: body.traceId
+      };
+    } catch {
+      problem = {
+        type: "about:blank",
+        title: response.statusText,
+        status: response.status,
+        detail: response.statusText
+      };
+    }
+    switch (response.status) {
+      case 401:
+        return new AuthenticationError(problem);
+      case 403:
+        return new ForbiddenError(problem);
+      case 404:
+        return new NotFoundError(problem);
+      case 422:
+        return new ValidationError(
+          problem
+        );
+      case 429: {
+        const retryAfter = response.headers.get("Retry-After");
+        return new RateLimitError(
+          problem,
+          retryAfter ? Number.parseInt(retryAfter, 10) : void 0
+        );
+      }
+      default:
+        return new ApiError(problem);
+    }
+  }
+  parse(schema, data) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      throw new SchemaError(`API response validation failed: ${result.error.message}`);
+    }
+    return result.data;
+  }
+  async backoff(attempt, error) {
+    let delay = Math.min(1e3 * 2 ** attempt, 1e4);
+    if (error instanceof RateLimitError && error.retryAfter) {
+      delay = error.retryAfter * 1e3;
+    }
+    delay += Math.random() * 500;
+    await new Promise((resolve5) => setTimeout(resolve5, delay));
+  }
+};
+
+// src/schemas/asset.ts
+import { z } from "zod";
+var AssetSummaryOutputSchema = z.object({
+  id: z.string().uuid(),
+  bundleId: z.string().uuid(),
+  assetType: z.string(),
+  logicalPath: z.string(),
+  contentSha256: z.string(),
+  contentSizeBytes: z.number().int().nullable().optional(),
+  mediaType: z.string().nullable().optional(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime().nullable().optional()
+});
+var AssetDetailOutputSchema = AssetSummaryOutputSchema.extend({
+  contentText: z.string().nullable().optional()
+});
+
+// src/schemas/bundle.ts
+import { z as z3 } from "zod";
+
+// src/schemas/common.ts
+import { z as z2 } from "zod";
+var BundleVisibility = z2.enum(["private", "public"]);
+var BundleVersionState = z2.enum(["published", "yanked"]);
+var AssetType = z2.enum([
+  "agent_definition",
+  "skill",
+  "tool_config",
+  "prompt",
+  "config",
+  "other"
+]);
+var BundleSourceType = z2.enum(["console", "registry"]);
+var PaginationMetaSchema = z2.object({
+  nextCursor: z2.string().nullable(),
+  hasMore: z2.boolean()
+});
+function paginatedSchema(itemSchema) {
+  return z2.object({
+    data: z2.array(itemSchema),
+    meta: PaginationMetaSchema
+  });
+}
+
+// src/schemas/bundle.ts
+var BundleOutputSchema = z3.object({
+  id: z3.string().uuid(),
+  namespace: z3.string(),
+  slug: z3.string(),
+  ref: z3.string(),
+  name: z3.string(),
+  description: z3.string().nullable().optional(),
+  visibility: BundleVisibility,
+  sourceType: BundleSourceType,
+  readmeFormat: z3.string().nullable().optional(),
+  createdAt: z3.string().datetime(),
+  updatedAt: z3.string().datetime().nullable().optional()
+});
+var BundleDetailOutputSchema = BundleOutputSchema.extend({
+  readmeContent: z3.string().nullable().optional(),
+  latestVersion: z3.string().nullable().optional(),
+  versionCount: z3.number().int(),
+  assetCount: z3.number().int()
+});
+
+// src/schemas/resolve.ts
+import { z as z4 } from "zod";
+var BundleLayerOutputSchema = z4.object({
+  assetId: z4.string(),
+  logicalPath: z4.string(),
+  assetType: z4.string(),
+  contentSha256: z4.string(),
+  sizeBytes: z4.number().int(),
+  mediaType: z4.string().nullable().optional()
+});
+var BundleManifestOutputSchema = z4.object({
+  layers: z4.array(BundleLayerOutputSchema)
+});
+var BundleResolveOutputSchema = z4.object({
+  bundleId: z4.string().uuid(),
+  versionId: z4.string().uuid(),
+  namespace: z4.string(),
+  slug: z4.string(),
+  ref: z4.string(),
+  version: z4.string(),
+  sourceType: BundleSourceType,
+  ociRef: z4.string().nullable().optional(),
+  ociDigest: z4.string().nullable().optional(),
+  state: BundleVersionState,
+  manifest: BundleManifestOutputSchema.nullable().optional()
+});
+
+// src/schemas/version.ts
+import { z as z5 } from "zod";
+var BundleVersionSummaryOutputSchema = z5.object({
+  id: z5.string().uuid(),
+  bundleId: z5.string().uuid(),
+  version: z5.string(),
+  state: BundleVersionState,
+  ociRef: z5.string().nullable().optional(),
+  ociDigest: z5.string().nullable().optional(),
+  publishedBy: z5.string().nullable().optional(),
+  yankedBy: z5.string().nullable().optional(),
+  yankedAt: z5.string().datetime().nullable().optional(),
+  yankReason: z5.string().nullable().optional(),
+  createdAt: z5.string().datetime()
+});
+var ManifestAssetOutputSchema = z5.object({
+  assetId: z5.string(),
+  logicalPath: z5.string(),
+  assetType: z5.string(),
+  contentSha256: z5.string(),
+  sizeBytes: z5.number().int(),
+  mediaType: z5.string().nullable().optional()
+});
+var ManifestDetailOutputSchema = z5.object({
+  namespace: z5.string(),
+  bundleSlug: z5.string(),
+  version: z5.string(),
+  assets: z5.array(ManifestAssetOutputSchema)
+});
+var BundleVersionDetailOutputSchema = z5.object({
+  id: z5.string().uuid(),
+  bundleId: z5.string().uuid(),
+  version: z5.string(),
+  state: BundleVersionState,
+  ociRef: z5.string().nullable().optional(),
+  ociDigest: z5.string().nullable().optional(),
+  manifest: ManifestDetailOutputSchema.nullable().optional(),
+  publishedBy: z5.string().nullable().optional(),
+  yankedBy: z5.string().nullable().optional(),
+  yankedAt: z5.string().datetime().nullable().optional(),
+  yankReason: z5.string().nullable().optional(),
+  createdAt: z5.string().datetime()
+});
+
+// src/resources/bundles.ts
+var BundlesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async get(namespace, bundle) {
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles/${enc(bundle)}`,
+      BundleDetailOutputSchema
+    );
+  }
+  async list(namespace, params) {
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles`,
+      paginatedSchema(BundleOutputSchema),
+      {
+        params: {
+          cursor: params?.cursor,
+          limit: params?.limit
+        }
+      }
+    );
+  }
+  async resolve(namespace, bundle, version, digest) {
+    const params = {};
+    if (version) {
+      params["version"] = version;
+    }
+    if (digest) {
+      params["digest"] = digest;
+    }
+    const hasParams = Object.keys(params).length > 0;
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles/${enc(bundle)}:resolve`,
+      BundleResolveOutputSchema,
+      hasParams ? { params } : void 0
+    );
+  }
+  async listVersions(namespace, bundle, params) {
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles/${enc(bundle)}/versions`,
+      paginatedSchema(BundleVersionSummaryOutputSchema),
+      {
+        params: {
+          cursor: params?.cursor,
+          limit: params?.limit
+        }
+      }
+    );
+  }
+  async getVersion(namespace, bundle, version) {
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles/${enc(bundle)}/versions/${enc(version)}`,
+      BundleVersionDetailOutputSchema
+    );
+  }
+  async listAssets(namespace, bundle, params) {
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles/${enc(bundle)}/assets`,
+      paginatedSchema(AssetSummaryOutputSchema),
+      {
+        params: {
+          cursor: params?.cursor,
+          limit: params?.limit
+        }
+      }
+    );
+  }
+  async getAsset(namespace, bundle, assetId, version) {
+    return this.http.request(
+      "GET",
+      `/v1/namespaces/${enc(namespace)}/bundles/${enc(bundle)}/assets/${enc(assetId)}`,
+      AssetDetailOutputSchema,
+      { params: { version } }
+    );
+  }
+};
+function enc(value) {
+  return encodeURIComponent(value);
+}
+
+// src/client.ts
+var _loadDeprecationWarned = false;
+var MusherClient = class {
+  bundles;
+  _cache;
+  _http;
+  constructor(config) {
+    const resolved = resolveConfig(config);
+    this._http = new HttpTransport(resolved);
+    this._cache = new BundleCache(
+      resolved.cacheDir,
+      resolved.baseUrl,
+      resolved.manifestTtlSeconds,
+      resolved.refTtlSeconds
+    );
+    this.bundles = new BundlesResource(this._http);
+  }
+  /**
+   * Resolve a bundle via the API, download all assets, and write to disk cache.
+   * Returns a Bundle object.
+   *
+   * @param ref - Bundle reference (e.g. "namespace/slug", "namespace/slug:version").
+   * @param version - Optional semver constraint. Defaults to latest.
+   */
+  async pull(ref, version) {
+    const parsed = BundleRef.parse(ref);
+    const resolvedVersion = version ?? parsed.version;
+    const resolved = await this.bundles.resolve(
+      parsed.namespace,
+      parsed.slug,
+      resolvedVersion,
+      parsed.digest
+    );
+    const assets = /* @__PURE__ */ new Map();
+    if (resolved.manifest?.layers) {
+      for (const layer of resolved.manifest.layers) {
+        const asset = await this.bundles.getAsset(
+          parsed.namespace,
+          parsed.slug,
+          layer.assetId,
+          resolved.version
+        );
+        if (asset.contentText != null) {
+          const buf = Buffer.from(asset.contentText, "utf-8");
+          const hash = createHash3("sha256").update(buf).digest("hex");
+          if (hash !== layer.contentSha256) {
+            throw new IntegrityError(layer.contentSha256, hash);
+          }
+          assets.set(layer.logicalPath, buf);
+        }
+      }
+    }
+    await this._cache.write(resolved, assets);
+    if (!parsed.digest) {
+      const refAlias = resolvedVersion ?? "latest";
+      await this._cache.cacheRef(parsed.namespace, parsed.slug, refAlias, resolved.version);
+    }
+    return new Bundle(resolved, assets);
+  }
+  /**
+   * Resolve bundle metadata without downloading content.
+   * Checks the manifest cache (with TTL) before calling the API.
+   *
+   * @param ref - Bundle reference.
+   * @param version - Optional semver constraint.
+   */
+  async resolve(ref, version) {
+    const parsed = BundleRef.parse(ref);
+    let resolvedVersion = version ?? parsed.version;
+    if (!(resolvedVersion || parsed.digest)) {
+      const cachedVersion = await this._cache.resolveRef(parsed.namespace, parsed.slug, "latest");
+      if (cachedVersion) {
+        resolvedVersion = cachedVersion;
+      }
+    }
+    if (resolvedVersion) {
+      const fresh = await this._cache.isFresh(parsed.namespace, parsed.slug, resolvedVersion);
+      if (fresh) {
+        const manifest = await this._cache.loadManifest(
+          parsed.namespace,
+          parsed.slug,
+          resolvedVersion
+        );
+        if (manifest) {
+          return manifest;
+        }
+      }
+    }
+    const resolved = await this.bundles.resolve(
+      parsed.namespace,
+      parsed.slug,
+      resolvedVersion,
+      parsed.digest
+    );
+    await this._cache.writeManifest(resolved);
+    if (!parsed.digest) {
+      const refAlias = resolvedVersion ?? "latest";
+      await this._cache.cacheRef(parsed.namespace, parsed.slug, refAlias, resolved.version);
+    }
+    return resolved;
+  }
+  /**
+   * @deprecated Use `pull()` instead. This method will be removed in a future version.
+   *
+   * Load a bundle into memory. Checks cache first (TTL-aware), pulls if stale.
+   */
+  async load(ref, version) {
+    if (!_loadDeprecationWarned) {
+      _loadDeprecationWarned = true;
+      process.emitWarning(
+        "MusherClient.load() is deprecated. Use pull() instead.",
+        "DeprecationWarning"
+      );
+    }
+    const parsed = BundleRef.parse(ref);
+    let resolvedVersion = version ?? parsed.version;
+    if (!(resolvedVersion || parsed.digest)) {
+      const cachedVersion = await this._cache.resolveRef(parsed.namespace, parsed.slug, "latest");
+      if (cachedVersion) {
+        resolvedVersion = cachedVersion;
+      }
+    }
+    if (resolvedVersion) {
+      const fresh = await this._cache.isFresh(parsed.namespace, parsed.slug, resolvedVersion);
+      if (fresh) {
+        const loaded = await this._cache.load(parsed.namespace, parsed.slug, resolvedVersion);
+        if (loaded) {
+          return loaded;
+        }
+      }
+    }
+    return this.pull(ref, version);
+  }
+  /** Cache management utilities. */
+  cache = {
+    /** Remove expired cache entries and garbage-collect unreferenced blobs. */
+    clean: () => this._cache.clean(),
+    /** Remove all cached data. */
+    purge: () => this._cache.purge()
+  };
+};
+
+// src/index.ts
+init_frontmatter();
+
+// src/adapters/index.ts
+init_claude();
+init_openai();
+init_vscode();
+
+// src/convenience.ts
+var _config;
+var _client;
+function configure(config) {
+  _config = config;
+  _client = void 0;
+}
+function getClient() {
+  if (!_client) {
+    _client = new MusherClient(_config);
+  }
+  return _client;
+}
+async function pull(ref, version) {
+  return getClient().pull(ref, version);
+}
+async function resolve4(ref, version) {
+  return getClient().resolve(ref, version);
+}
+export {
+  AgentSpecHandle,
+  ApiError,
+  AssetDetailOutputSchema,
+  AssetSummaryOutputSchema,
+  AssetType,
+  AuthenticationError,
+  Bundle,
+  BundleDetailOutputSchema,
+  BundleLayerOutputSchema,
+  BundleManifestOutputSchema,
+  BundleOutputSchema,
+  BundleRef,
+  BundleResolveOutputSchema,
+  BundleSourceType,
+  BundleVersionDetailOutputSchema,
+  BundleVersionState,
+  BundleVersionSummaryOutputSchema,
+  BundleVisibility,
+  CacheError,
+  FileHandle,
+  ForbiddenError,
+  IntegrityError,
+  ManifestAssetOutputSchema,
+  ManifestDetailOutputSchema,
+  MushError,
+  MusherClient,
+  NetworkError,
+  NotFoundError,
+  PaginationMetaSchema,
+  PromptHandle,
+  RateLimitError,
+  SchemaError,
+  Selection,
+  SkillHandle,
+  TimeoutError,
+  ToolsetHandle,
+  ValidationError,
+  configure,
+  exportClaudePlugin,
+  exportOpenAIInlineSkill,
+  exportOpenAILocalSkill,
+  extractDescription,
+  getClient,
+  installClaudeSkills,
+  installVSCodeSkills,
+  paginatedSchema,
+  parseFrontmatter,
+  pull,
+  resolve4 as resolve,
+  resolveMusherDirs
+};
+//# sourceMappingURL=index.js.map