openpond 0.0.38 → 0.0.39

package/dist/chunks/chunk-FWLOFUPU.js

@@ -1,864 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  parseProfileSkillMarkdown
-} from "./chunk-V35STJF4.js";
-import {
-  openPondConfigDirectory,
-  updatePrivateJsonFile
-} from "./chunk-ZI4GDAUB.js";
-
-// ../../packages/cloud/src/extensions/extension-manager.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import path2 from "node:path";
-
-// ../../packages/cloud/src/extensions/github-source.ts
-import { createHash } from "node:crypto";
-import path from "node:path";
-
-// ../../packages/cloud/src/extensions/types.ts
-var GithubExtensionError = class extends Error {
-  code;
-  status;
-  constructor(message, options) {
-    super(message);
-    this.name = "GithubExtensionError";
-    this.code = options.code;
-    this.status = options.status ?? 400;
-  }
-};
-
-// ../../packages/cloud/src/extensions/github-source.ts
-var DEFAULT_REF = "HEAD";
-var MAX_EXTENSION_SKILLS = 64;
-var MAX_EXTENSION_FILES = 512;
-var MAX_EXTENSION_BYTES = 20 * 1024 * 1024;
-var MAX_EXTENSION_FILE_BYTES = 5 * 1024 * 1024;
-var DOWNLOAD_CONCURRENCY = 8;
-var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var GITHUB_REPOSITORY_PATTERN = /^[A-Za-z0-9_.-]+$/;
-var ROOT_SKILL_RESOURCE_DIRECTORIES = /* @__PURE__ */ new Set(["agents", "assets", "references", "scripts"]);
-function createGithubSourceClient(options = {}) {
-  const fetchImpl = options.fetch ?? fetch;
-  const githubToken = options.githubToken?.trim() || process.env.GITHUB_TOKEN?.trim() || process.env.GH_TOKEN?.trim() || null;
-  return {
-    async resolve(request) {
-      const source = await resolveSource(request, fetchImpl, githubToken);
-      const preview = await buildPreview(source, fetchImpl, githubToken);
-      return {
-        preview,
-        files: filesToDownload(source)
-      };
-    },
-    async download(resolution, writeFile2) {
-      await downloadFiles({
-        resolution,
-        fetchImpl,
-        githubToken,
-        writeFile: writeFile2
-      });
-    }
-  };
-}
-function parseGithubExtensionSource(source) {
-  const trimmed = source.trim();
-  let owner = "";
-  let repo = "";
-  if (/^(?:https?:\/\/)?github\.com\//i.test(trimmed)) {
-    const url = new URL(trimmed.startsWith("http") ? trimmed : `https://${trimmed}`);
-    if (url.hostname.toLowerCase() !== "github.com") {
-      throw invalidSource(source);
-    }
-    const segments = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
-    if (segments.length !== 2) throw invalidSource(source);
-    [owner = "", repo = ""] = segments;
-  } else {
-    const normalized = trimmed.replace(/^github:/i, "").replace(/^\/+|\/+$/g, "");
-    const segments = normalized.split("/");
-    if (segments.length !== 2) throw invalidSource(source);
-    [owner = "", repo = ""] = segments;
-  }
-  repo = repo.replace(/\.git$/i, "");
-  if (!GITHUB_REPOSITORY_PATTERN.test(owner) || !GITHUB_REPOSITORY_PATTERN.test(repo)) {
-    throw invalidSource(source);
-  }
-  const normalizedOwner = owner.toLowerCase();
-  const normalizedRepo = repo.toLowerCase();
-  return {
-    id: `github:${normalizedOwner}/${normalizedRepo}`,
-    owner: normalizedOwner,
-    repo: normalizedRepo,
-    repositoryUrl: `https://github.com/${normalizedOwner}/${normalizedRepo}`
-  };
-}
-async function resolveSource(request, fetchImpl, githubToken) {
-  const identity = parseGithubExtensionSource(request.source);
-  const requestedRef = request.ref?.trim() || DEFAULT_REF;
-  const repository = await githubJson(fetchImpl, githubToken, `/repos/${identity.owner}/${identity.repo}`);
-  const resolvedRef = requestedRef === DEFAULT_REF ? repository.default_branch?.trim() || "main" : requestedRef;
-  const commit = await githubJson(
-    fetchImpl,
-    githubToken,
-    `/repos/${identity.owner}/${identity.repo}/commits/${encodeURIComponent(resolvedRef)}`
-  );
-  const resolvedCommit = commit.sha?.trim();
-  const treeSha = commit.commit?.tree?.sha?.trim();
-  if (!resolvedCommit || !treeSha) {
-    throw new GithubExtensionError("GitHub returned an incomplete commit response.", {
-      code: "github_invalid_commit",
-      status: 502
-    });
-  }
-  const treePayload = await githubJson(
-    fetchImpl,
-    githubToken,
-    `/repos/${identity.owner}/${identity.repo}/git/trees/${treeSha}?recursive=1`
-  );
-  if (treePayload.truncated) {
-    throw new GithubExtensionError("The GitHub repository tree is too large to install safely.", {
-      code: "github_tree_truncated"
-    });
-  }
-  const tree = (treePayload.tree ?? []).filter(validTreeEntry);
-  const skillPackages = discoverSkillPackages(tree);
-  if (skillPackages.length === 0) {
-    throw new GithubExtensionError(
-      "No skills found. Add SKILL.md at the repository root or use a standard agent skills directory.",
-      { code: "extension_no_skills" }
-    );
-  }
-  if (skillPackages.length > MAX_EXTENSION_SKILLS) {
-    throw new GithubExtensionError(`Extension contains more than ${MAX_EXTENSION_SKILLS} skills.`, {
-      code: "extension_too_many_skills"
-    });
-  }
-  validateDownloadLimits(skillPackages);
-  const readme = tree.find((entry) => entry.type === "blob" && /^readme(?:\.[^/]+)?$/i.test(entry.path)) ?? null;
-  return { identity, requestedRef, resolvedCommit, tree, skillPackages, readme };
-}
-async function buildPreview(source, fetchImpl, githubToken) {
-  const skills = await mapConcurrent(source.skillPackages, DOWNLOAD_CONCURRENCY, async (skillPackage) => {
-    const contents = await downloadText(source, skillPackage.entry, fetchImpl, githubToken);
-    return previewSkill(skillPackage, contents);
-  });
-  const duplicateNames = duplicateValues(skills.map((skill) => skill.name));
-  for (const skill of skills) {
-    if (!duplicateNames.has(skill.name)) continue;
-    skill.validationStatus = "error";
-    skill.validationMessages = [...skill.validationMessages, `Duplicate skill name: ${skill.name}`];
-  }
-  const validationMessages = skills.flatMap(
-    (skill) => skill.validationMessages.map((message) => `${skill.relativePath}: ${message}`)
-  );
-  const packageFiles = filesToDownload(source);
-  return {
-    ...source.identity,
-    source: "github",
-    requestedRef: source.requestedRef,
-    resolvedCommit: source.resolvedCommit,
-    sourcePath: null,
-    readmePath: source.readme?.path ?? null,
-    packageHash: hashTree(packageFiles),
-    skills: skills.sort((left, right) => left.name.localeCompare(right.name)),
-    validationStatus: validationMessages.length === 0 ? "valid" : "error",
-    validationMessages
-  };
-}
-function previewSkill(skillPackage, contents) {
-  const parsed = parseProfileSkillMarkdown(contents);
-  const directoryName = skillPackage.root === "." ? null : path.posix.basename(skillPackage.root);
-  const name = parsed.name ?? directoryName ?? "invalid-skill";
-  const messages = [...parsed.messages];
-  if (!SKILL_NAME_PATTERN.test(name)) messages.push("Skill name must be lowercase kebab-case.");
-  if (directoryName && name !== directoryName) {
-    messages.push(`Skill name must match its directory name (${directoryName}).`);
-  }
-  const resourceFiles = skillPackage.files.filter((file) => file.path !== skillPackage.entry.path).map((file) => relativeSkillPath(skillPackage.root, file.path)).sort();
-  return {
-    name,
-    description: parsed.description ?? "",
-    relativePath: skillPackage.root === "." ? "SKILL.md" : `${skillPackage.root}/SKILL.md`,
-    sourcePath: "",
-    charCount: contents.length,
-    sourceHash: createHash("sha256").update(contents).digest("hex"),
-    resourceFiles,
-    validationStatus: messages.length === 0 ? "valid" : "error",
-    validationMessages: [...new Set(messages)]
-  };
-}
-function discoverSkillPackages(tree) {
-  const entries = [];
-  const rootEntry = tree.find((entry) => entry.type === "blob" && entry.path === "SKILL.md");
-  if (rootEntry) entries.push({ root: ".", entry: rootEntry });
-  const skillEntries = tree.filter((entry) => entry.type === "blob" && entry.path.endsWith("/SKILL.md"));
-  const standardEntries = skillEntries.filter((entry) => isStandardAgentSkillsPath(entry.path));
-  const discoveredEntries = standardEntries.length > 0 ? standardEntries : skillEntries;
-  const roots = new Set(discoveredEntries.map((entry) => path.posix.dirname(entry.path)));
-  for (const entry of discoveredEntries) {
-    const root = path.posix.dirname(entry.path);
-    if ([...roots].some((candidate) => candidate !== root && root.startsWith(`${candidate}/`))) continue;
-    entries.push({ root, entry });
-  }
-  return entries.map(({ root, entry }) => {
-    const files = tree.filter((candidate) => {
-      if (candidate.type !== "blob") return false;
-      if (root !== ".") return candidate.path.startsWith(`${root}/`);
-      if (candidate.path === "SKILL.md") return true;
-      const firstSegment = candidate.path.split("/", 1)[0] ?? "";
-      return ROOT_SKILL_RESOURCE_DIRECTORIES.has(firstSegment);
-    });
-    const unsafe = tree.find(
-      (candidate) => candidate.type !== "blob" && candidate.type !== "tree" && (root === "." ? candidate.path === "SKILL.md" || ROOT_SKILL_RESOURCE_DIRECTORIES.has(candidate.path.split("/", 1)[0] ?? "") : candidate.path.startsWith(`${root}/`))
-    );
-    const symlink = files.find((candidate) => candidate.mode === "120000");
-    if (unsafe || symlink) {
-      throw new GithubExtensionError(`Skill package ${root} contains a symlink or submodule.`, {
-        code: "extension_unsafe_entry"
-      });
-    }
-    return { root, entry, files };
-  });
-}
-function isStandardAgentSkillsPath(skillPath) {
-  const segments = skillPath.split("/");
-  if (segments.at(-1) !== "SKILL.md") return false;
-  const skillDirectorySegments = segments.slice(0, -1);
-  if (skillDirectorySegments.length < 2) return false;
-  const skillsIndex = skillDirectorySegments.lastIndexOf("skills");
-  if (skillsIndex < 0 || skillsIndex > 2) return false;
-  const containerPrefix = skillDirectorySegments.slice(0, skillsIndex);
-  const nestedSkillPath = skillDirectorySegments.slice(skillsIndex + 1);
-  if (nestedSkillPath.length < 1 || nestedSkillPath.length > 2) return false;
-  if (skillsIndex === 0) return true;
-  const first = containerPrefix[0] ?? "";
-  return first.startsWith(".") || first === "agent" || first === "data";
-}
-function filesToDownload(source) {
-  const byPath = /* @__PURE__ */ new Map();
-  if (source.readme) byPath.set(source.readme.path, source.readme);
-  for (const skillPackage of source.skillPackages) {
-    for (const file of skillPackage.files) byPath.set(file.path, file);
-  }
-  return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
-}
-async function downloadFiles(input) {
-  let downloadedBytes = 0;
-  await mapConcurrent(input.resolution.files, DOWNLOAD_CONCURRENCY, async (file) => {
-    const bytes = await downloadBytes({
-      owner: input.resolution.preview.owner,
-      repo: input.resolution.preview.repo,
-      commit: input.resolution.preview.resolvedCommit,
-      file,
-      fetchImpl: input.fetchImpl,
-      githubToken: input.githubToken
-    });
-    downloadedBytes += bytes.byteLength;
-    if (downloadedBytes > MAX_EXTENSION_BYTES) {
-      throw new GithubExtensionError("Extension download exceeds the maximum allowed size.", {
-        code: "extension_too_large"
-      });
-    }
-    await input.writeFile(file.path, bytes, file.mode === "100755");
-  });
-}
-async function downloadText(source, file, fetchImpl, githubToken) {
-  const bytes = await downloadBytes({
-    owner: source.identity.owner,
-    repo: source.identity.repo,
-    commit: source.resolvedCommit,
-    file,
-    fetchImpl,
-    githubToken
-  });
-  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-}
-async function downloadBytes(input) {
-  const encodedPath = input.file.path.split("/").map(encodeURIComponent).join("/");
-  const url = `https://raw.githubusercontent.com/${input.owner}/${input.repo}/${input.commit}/${encodedPath}`;
-  const response = await input.fetchImpl(url, {
-    headers: githubHeaders(input.githubToken, "application/vnd.github.raw"),
-    redirect: "follow"
-  });
-  if (!response.ok) {
-    throw new GithubExtensionError(`GitHub file download failed (${response.status}): ${input.file.path}`, {
-      code: "github_download_failed",
-      status: response.status
-    });
-  }
-  const contentLength = Number(response.headers.get("content-length"));
-  if (Number.isFinite(contentLength) && contentLength > MAX_EXTENSION_FILE_BYTES) {
-    throw new GithubExtensionError(`Extension file is too large: ${input.file.path}`, {
-      code: "extension_file_too_large"
-    });
-  }
-  const bytes = new Uint8Array(await response.arrayBuffer());
-  if (bytes.byteLength > MAX_EXTENSION_FILE_BYTES) {
-    throw new GithubExtensionError(`Extension file is too large: ${input.file.path}`, {
-      code: "extension_file_too_large"
-    });
-  }
-  return bytes;
-}
-async function githubJson(fetchImpl, githubToken, pathname) {
-  const response = await fetchImpl(`https://api.github.com${pathname}`, {
-    headers: githubHeaders(githubToken, "application/vnd.github+json")
-  });
-  if (!response.ok) {
-    const details = await response.json().catch(() => null);
-    const detail = typeof details?.message === "string" ? `: ${details.message}` : "";
-    throw new GithubExtensionError(`GitHub request failed (${response.status})${detail}`, {
-      code: response.status === 404 ? "github_repository_not_found" : "github_request_failed",
-      status: response.status
-    });
-  }
-  return await response.json();
-}
-function githubHeaders(token, accept) {
-  const headers = new Headers({
-    Accept: accept,
-    "User-Agent": "openpond-extension-installer",
-    "X-GitHub-Api-Version": "2022-11-28"
-  });
-  if (token) headers.set("Authorization", `Bearer ${token}`);
-  return headers;
-}
-function validateDownloadLimits(skillPackages) {
-  const files = /* @__PURE__ */ new Map();
-  for (const skillPackage of skillPackages) {
-    for (const file of skillPackage.files) files.set(file.path, file);
-  }
-  if (files.size > MAX_EXTENSION_FILES) {
-    throw new GithubExtensionError(`Extension contains more than ${MAX_EXTENSION_FILES} skill files.`, {
-      code: "extension_too_many_files"
-    });
-  }
-  let totalBytes = 0;
-  for (const file of files.values()) {
-    if ((file.size ?? 0) > MAX_EXTENSION_FILE_BYTES) {
-      throw new GithubExtensionError(`Extension file is too large: ${file.path}`, {
-        code: "extension_file_too_large"
-      });
-    }
-    totalBytes += file.size ?? 0;
-  }
-  if (totalBytes > MAX_EXTENSION_BYTES) {
-    throw new GithubExtensionError("Extension exceeds the maximum allowed size.", {
-      code: "extension_too_large"
-    });
-  }
-}
-function validTreeEntry(value) {
-  if (!value || typeof value !== "object") return false;
-  const entry = value;
-  return typeof entry.path === "string" && !entry.path.startsWith("/") && !entry.path.split("/").includes("..") && typeof entry.mode === "string" && (entry.type === "blob" || entry.type === "tree" || entry.type === "commit") && typeof entry.sha === "string";
-}
-function hashTree(files) {
-  const hash = createHash("sha256");
-  for (const file of files) hash.update(`${file.path}\0${file.sha}\0${file.size ?? ""}
-`);
-  return hash.digest("hex");
-}
-function relativeSkillPath(root, filePath) {
-  return root === "." ? filePath : filePath.slice(root.length + 1);
-}
-function duplicateValues(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    if (seen.has(value)) duplicates.add(value);
-    seen.add(value);
-  }
-  return duplicates;
-}
-async function mapConcurrent(values, concurrency, mapper) {
-  const results = new Array(values.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < values.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      results[index] = await mapper(values[index]);
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, worker));
-  return results;
-}
-function invalidSource(source) {
-  return new GithubExtensionError(
-    `Invalid GitHub extension source: ${source}. Use owner/repo or https://github.com/owner/repo.`,
-    { code: "github_invalid_source" }
-  );
-}
-
-// ../../packages/cloud/src/extensions/extension-manager.ts
-var REGISTRY_SCHEMA_VERSION = 1;
-var OPERATION_LOCK_STALE_MS = 2 * 60 * 1e3;
-var OPERATION_LOCK_TIMEOUT_MS = 15e3;
-function createGithubExtensionManager(options = {}) {
-  const rootPath = path2.resolve(options.rootPath ?? path2.join(openPondConfigDirectory(), "extensions"));
-  const registryPath = path2.join(rootPath, "registry.json");
-  const github = createGithubSourceClient({
-    fetch: options.fetch,
-    githubToken: options.githubToken
-  });
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  async function list() {
-    try {
-      const registry = await readRegistry(registryPath);
-      const extensions = await Promise.all(registry.extensions.map((extension) => hydrateExtension(rootPath, extension)));
-      markInstalledSkillConflicts(extensions, await reservedSkillNames(options.reservedSkillNames));
-      return {
-        rootPath,
-        registryPath,
-        extensions: extensions.sort(extensionSort),
-        error: null
-      };
-    } catch (error) {
-      return {
-        rootPath,
-        registryPath,
-        extensions: [],
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async function preview(request) {
-    const resolution = await github.resolve(request);
-    const registry = await readRegistry(registryPath);
-    const existing = registry.extensions.find((extension) => extension.id === resolution.preview.id) ?? null;
-    assertSkillNamesAvailable(
-      resolution.preview,
-      registry.extensions.filter((extension) => extension.id !== existing?.id),
-      await reservedSkillNames(options.reservedSkillNames)
-    );
-    return resolution.preview;
-  }
-  async function add(request) {
-    const identity = parseGithubExtensionSource(request.source);
-    return withExtensionLock(rootPath, identity.id, async () => {
-      const registry = await readRegistry(registryPath);
-      if (registry.extensions.some((extension) => extension.id === identity.id)) {
-        throw new GithubExtensionError(`${identity.owner}/${identity.repo} is already installed.`, {
-          code: "extension_already_installed",
-          status: 409
-        });
-      }
-      const resolution = await github.resolve(request);
-      assertInstallable(resolution.preview);
-      assertSkillNamesAvailable(
-        resolution.preview,
-        registry.extensions,
-        await reservedSkillNames(options.reservedSkillNames)
-      );
-      const timestamp = now().toISOString();
-      const installed = await materializeExtension({
-        rootPath,
-        resolution,
-        installedAt: timestamp,
-        updatedAt: timestamp,
-        github
-      });
-      try {
-        const reserved = await reservedSkillNames(options.reservedSkillNames);
-        await writeRegistry(registryPath, now, (current) => ({
-          ...current,
-          extensions: appendInstalledExtension(current, installed, reserved)
-        }));
-        await finalizeMaterialization(rootPath, installed.id);
-        return installed;
-      } catch (error) {
-        await rollbackMaterialization(rootPath, installed.id);
-        throw error;
-      }
-    });
-  }
-  async function update(request) {
-    const identity = parseGithubExtensionSource(request.source);
-    return withExtensionLock(rootPath, identity.id, async () => {
-      const registry = await readRegistry(registryPath);
-      const existing = requireInstalled(registry, identity.id);
-      const resolution = await github.resolve({
-        source: existing.repositoryUrl,
-        ref: request.ref?.trim() || existing.requestedRef
-      });
-      assertInstallable(resolution.preview);
-      assertSkillNamesAvailable(
-        resolution.preview,
-        registry.extensions.filter((extension) => extension.id !== existing.id),
-        await reservedSkillNames(options.reservedSkillNames)
-      );
-      if (existing.resolvedCommit === resolution.preview.resolvedCommit && existing.packageHash === resolution.preview.packageHash && existing.requestedRef === resolution.preview.requestedRef) {
-        return hydrateExtension(rootPath, existing);
-      }
-      const installed = await materializeExtension({
-        rootPath,
-        resolution,
-        installedAt: existing.installedAt,
-        updatedAt: now().toISOString(),
-        github
-      });
-      try {
-        const reserved = await reservedSkillNames(options.reservedSkillNames);
-        await writeRegistry(registryPath, now, (current) => ({
-          ...current,
-          extensions: replaceInstalledExtension(current, installed, reserved)
-        }));
-        await finalizeMaterialization(rootPath, installed.id);
-        return installed;
-      } catch (error) {
-        await rollbackMaterialization(rootPath, installed.id);
-        throw error;
-      }
-    });
-  }
-  async function updateAll() {
-    const catalog = await list();
-    if (catalog.error) throw new GithubExtensionError(catalog.error, { code: "extension_registry_error" });
-    const result = { updated: [], unchanged: [], failed: [] };
-    for (const extension of catalog.extensions) {
-      try {
-        const next = await update({ source: extension.repositoryUrl, ref: extension.requestedRef });
-        if (next.resolvedCommit === extension.resolvedCommit && next.packageHash === extension.packageHash) {
-          result.unchanged.push(next);
-        } else {
-          result.updated.push(next);
-        }
-      } catch (error) {
-        result.failed.push({
-          id: extension.id,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    return result;
-  }
-  async function inspect(source) {
-    const identity = parseGithubExtensionSource(source);
-    const registry = await readRegistry(registryPath);
-    return hydrateExtension(rootPath, requireInstalled(registry, identity.id));
-  }
-  async function remove(source) {
-    const identity = parseGithubExtensionSource(source);
-    return withExtensionLock(rootPath, identity.id, async () => {
-      const registry = await readRegistry(registryPath);
-      const existing = requireInstalled(registry, identity.id);
-      const target = extensionDirectory(rootPath, identity.owner, identity.repo);
-      const trash = `${target}.${randomUUID()}.remove`;
-      if (existsSync(target)) await rename(target, trash);
-      try {
-        await writeRegistry(registryPath, now, (current) => ({
-          ...current,
-          extensions: current.extensions.filter((extension) => extension.id !== existing.id)
-        }));
-        await rm(trash, { recursive: true, force: true });
-        return existing;
-      } catch (error) {
-        if (existsSync(trash) && !existsSync(target)) await rename(trash, target);
-        throw error;
-      }
-    });
-  }
-  async function readSkill(nameInput) {
-    const name = nameInput.trim();
-    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
-      throw new GithubExtensionError("Extension skill name must be lowercase kebab-case.", {
-        code: "extension_skill_invalid_name"
-      });
-    }
-    const catalog = await list();
-    if (catalog.error) {
-      throw new GithubExtensionError(catalog.error, { code: "extension_registry_error" });
-    }
-    const matches = catalog.extensions.flatMap(
-      (extension) => extension.skills.filter((skill) => skill.name === name).map((skill) => ({ extension, skill }))
-    );
-    if (matches.length === 0) {
-      throw new GithubExtensionError(`Extension skill not found: ${name}`, {
-        code: "extension_skill_not_found",
-        status: 404
-      });
-    }
-    if (matches.length > 1) {
-      throw new GithubExtensionError(`Extension skill name is ambiguous: ${name}`, {
-        code: "extension_skill_conflict",
-        status: 409
-      });
-    }
-    const match = matches[0];
-    if (match.extension.validationStatus !== "valid" || match.skill.validationStatus !== "valid") {
-      throw new GithubExtensionError(`Extension skill ${name} is not valid.`, {
-        code: "extension_skill_invalid"
-      });
-    }
-    const absolutePath = safeDestination(match.extension.sourcePath, match.skill.relativePath);
-    const markdown = await readFile(absolutePath, "utf8");
-    const sourceHash = createHash2("sha256").update(markdown).digest("hex");
-    if (sourceHash !== match.skill.sourceHash) {
-      throw new GithubExtensionError(
-        `Extension skill ${name} changed on disk. Update or reinstall its extension before using it.`,
-        { code: "extension_skill_modified" }
-      );
-    }
-    const parsed = parseProfileSkillMarkdown(markdown);
-    if (parsed.messages.length > 0 || parsed.name !== name || !parsed.description) {
-      throw new GithubExtensionError(
-        `Extension skill ${name} is not valid. ${parsed.messages.join(" ")}`.trim(),
-        { code: "extension_skill_invalid" }
-      );
-    }
-    return {
-      name,
-      description: parsed.description,
-      body: parsed.body,
-      path: match.skill.relativePath,
-      sourcePath: match.extension.sourcePath,
-      sourceHash,
-      charCount: markdown.length,
-      packagePath: path2.dirname(absolutePath),
-      resourceFiles: match.skill.resourceFiles
-    };
-  }
-  return { rootPath, registryPath, list, preview, add, update, updateAll, inspect, remove, readSkill };
-}
-async function materializeExtension(input) {
-  const preview = input.resolution.preview;
-  const target = extensionDirectory(input.rootPath, preview.owner, preview.repo);
-  const temporary = `${target}.${randomUUID()}.install`;
-  const backup = backupDirectory(input.rootPath, preview.id);
-  const current = path2.join(temporary, "current");
-  await rm(temporary, { recursive: true, force: true });
-  await rm(backup, { recursive: true, force: true });
-  await mkdir(current, { recursive: true, mode: 448 });
-  try {
-    await input.github.download(input.resolution, async (relativePath, bytes, executable) => {
-      const destination = safeDestination(current, relativePath);
-      await mkdir(path2.dirname(destination), { recursive: true, mode: 448 });
-      await writeFile(destination, bytes, { mode: executable ? 448 : 384 });
-    });
-    const extension = installedExtension(preview, target, input.installedAt, input.updatedAt);
-    await writeFile(
-      path2.join(temporary, "extension.json"),
-      `${JSON.stringify(extension, null, 2)}
-`,
-      { mode: 384 }
-    );
-    await mkdir(path2.dirname(target), { recursive: true, mode: 448 });
-    if (existsSync(target)) await rename(target, backup);
-    await rename(temporary, target);
-    return extension;
-  } catch (error) {
-    await rm(temporary, { recursive: true, force: true });
-    if (existsSync(backup) && !existsSync(target)) await rename(backup, target);
-    throw error;
-  }
-}
-function installedExtension(preview, target, installedAt, updatedAt) {
-  const sourcePath = path2.join(target, "current");
-  return {
-    ...preview,
-    sourcePath,
-    readmePath: preview.readmePath ? path2.join(sourcePath, preview.readmePath) : null,
-    installedAt,
-    updatedAt,
-    skills: preview.skills.map((skill) => ({
-      ...skill,
-      sourcePath: path2.join(sourcePath, skill.relativePath)
-    }))
-  };
-}
-async function finalizeMaterialization(rootPath, id) {
-  await rm(backupDirectory(rootPath, id), { recursive: true, force: true });
-}
-async function rollbackMaterialization(rootPath, id) {
-  const identity = parseGithubExtensionSource(id.replace(/^github:/, ""));
-  const target = extensionDirectory(rootPath, identity.owner, identity.repo);
-  const backup = backupDirectory(rootPath, id);
-  await rm(target, { recursive: true, force: true });
-  if (existsSync(backup)) await rename(backup, target);
-}
-async function hydrateExtension(rootPath, extension) {
-  const target = extensionDirectory(rootPath, extension.owner, extension.repo);
-  const sourcePath = path2.join(target, "current");
-  const present = (await stat(path2.join(target, "extension.json")).catch(() => null))?.isFile() ?? false;
-  const validationMessages = extension.validationMessages.filter((message) => message !== "Installed files are missing.");
-  if (!present) validationMessages.push("Installed files are missing.");
-  return {
-    ...extension,
-    sourcePath,
-    readmePath: extension.readmePath ? path2.join(sourcePath, path2.basename(extension.readmePath)) : null,
-    skills: extension.skills.map((skill) => ({
-      ...skill,
-      sourcePath: path2.join(sourcePath, skill.relativePath)
-    })),
-    validationStatus: validationMessages.length === 0 ? "valid" : "error",
-    validationMessages
-  };
-}
-function assertInstallable(preview) {
-  if (preview.validationStatus === "valid") return;
-  throw new GithubExtensionError(
-    `Extension contains invalid skills: ${preview.validationMessages.join(" ")}`,
-    { code: "extension_invalid" }
-  );
-}
-function assertSkillNamesAvailable(preview, installed, reserved) {
-  const owners = /* @__PURE__ */ new Map();
-  for (const name of reserved) owners.set(name, "a shipped OpenPond skill");
-  for (const extension of installed) {
-    for (const skill of extension.skills) owners.set(skill.name, extension.id);
-  }
-  const conflicts = preview.skills.map((skill) => ({ name: skill.name, owner: owners.get(skill.name) })).filter((entry) => Boolean(entry.owner));
-  if (conflicts.length === 0) return;
-  throw new GithubExtensionError(
-    `Skill name conflict: ${conflicts.map((entry) => `${entry.name} (${entry.owner})`).join(", ")}.`,
-    { code: "extension_skill_conflict", status: 409 }
-  );
-}
-function appendInstalledExtension(registry, installed, reserved) {
-  if (registry.extensions.some((extension) => extension.id === installed.id)) {
-    throw new GithubExtensionError(`${installed.owner}/${installed.repo} is already installed.`, {
-      code: "extension_already_installed",
-      status: 409
-    });
-  }
-  assertSkillNamesAvailable(installed, registry.extensions, reserved);
-  return [...registry.extensions, installed].sort(extensionSort);
-}
-function replaceInstalledExtension(registry, installed, reserved) {
-  requireInstalled(registry, installed.id);
-  assertSkillNamesAvailable(
-    installed,
-    registry.extensions.filter((extension) => extension.id !== installed.id),
-    reserved
-  );
-  return registry.extensions.map((extension) => extension.id === installed.id ? installed : extension).sort(extensionSort);
-}
-function markInstalledSkillConflicts(extensions, reserved) {
-  const owners = /* @__PURE__ */ new Map();
-  for (const name of reserved) owners.set(name, "built-in");
-  for (const extension of extensions) {
-    for (const skill of extension.skills) {
-      const owner = owners.get(skill.name);
-      if (!owner) {
-        owners.set(skill.name, extension.id);
-        continue;
-      }
-      const message = `Skill name conflicts with ${owner}: ${skill.name}`;
-      skill.validationStatus = "error";
-      skill.validationMessages = [.../* @__PURE__ */ new Set([...skill.validationMessages, message])];
-      extension.validationStatus = "error";
-      extension.validationMessages = [.../* @__PURE__ */ new Set([...extension.validationMessages, message])];
-    }
-  }
-}
-async function reservedSkillNames(source) {
-  const values = typeof source === "function" ? await source() : source ?? [];
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}
-function requireInstalled(registry, id) {
-  const extension = registry.extensions.find((candidate) => candidate.id === id);
-  if (extension) return extension;
-  throw new GithubExtensionError(`${id.replace(/^github:/, "")} is not installed.`, {
-    code: "extension_not_installed",
-    status: 404
-  });
-}
-async function readRegistry(registryPath) {
-  try {
-    const parsed = JSON.parse(await readFile(registryPath, "utf8"));
-    if (parsed.schemaVersion !== REGISTRY_SCHEMA_VERSION || !Array.isArray(parsed.extensions)) {
-      throw new Error("Extension registry has an unsupported format.");
-    }
-    return {
-      schemaVersion: REGISTRY_SCHEMA_VERSION,
-      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : null,
-      extensions: parsed.extensions.filter(isStoredExtension)
-    };
-  } catch (error) {
-    if (error.code === "ENOENT") return emptyRegistry();
-    throw error;
-  }
-}
-async function writeRegistry(registryPath, now, update) {
-  await updatePrivateJsonFile(registryPath, emptyRegistry, (current) => ({
-    ...update(normalizeRegistry(current)),
-    schemaVersion: REGISTRY_SCHEMA_VERSION,
-    updatedAt: now().toISOString()
-  }));
-}
-function normalizeRegistry(value) {
-  return {
-    schemaVersion: REGISTRY_SCHEMA_VERSION,
-    updatedAt: typeof value?.updatedAt === "string" ? value.updatedAt : null,
-    extensions: Array.isArray(value?.extensions) ? value.extensions.filter(isStoredExtension) : []
-  };
-}
-function emptyRegistry() {
-  return { schemaVersion: REGISTRY_SCHEMA_VERSION, updatedAt: null, extensions: [] };
-}
-function isStoredExtension(value) {
-  if (!value || typeof value !== "object") return false;
-  const extension = value;
-  return extension.source === "github" && typeof extension.id === "string" && typeof extension.owner === "string" && typeof extension.repo === "string" && typeof extension.repositoryUrl === "string" && typeof extension.requestedRef === "string" && typeof extension.resolvedCommit === "string" && Array.isArray(extension.skills);
-}
-function safeDestination(root, relativePath) {
-  if (path2.isAbsolute(relativePath) || relativePath.split(/[\\/]/).includes("..")) {
-    throw new GithubExtensionError(`Unsafe extension path: ${relativePath}`, {
-      code: "extension_unsafe_path"
-    });
-  }
-  const destination = path2.resolve(root, ...relativePath.split("/"));
-  const prefix = `${path2.resolve(root)}${path2.sep}`;
-  if (!destination.startsWith(prefix)) {
-    throw new GithubExtensionError(`Unsafe extension path: ${relativePath}`, {
-      code: "extension_unsafe_path"
-    });
-  }
-  return destination;
-}
-function extensionDirectory(rootPath, owner, repo) {
-  return path2.join(rootPath, "github", owner, repo);
-}
-function backupDirectory(rootPath, id) {
-  const identity = parseGithubExtensionSource(id.replace(/^github:/, ""));
-  return `${extensionDirectory(rootPath, identity.owner, identity.repo)}.previous`;
-}
-async function withExtensionLock(rootPath, id, operation) {
-  const safeId = id.replace(/[^a-z0-9.-]+/gi, "-");
-  const lockPath = path2.join(rootPath, ".locks", `${safeId}.lock`);
-  await mkdir(path2.dirname(lockPath), { recursive: true, mode: 448 });
-  const deadline = Date.now() + OPERATION_LOCK_TIMEOUT_MS;
-  while (true) {
-    try {
-      await mkdir(lockPath, { mode: 448 });
-      break;
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      const lockStat = await stat(lockPath).catch(() => null);
-      if (lockStat && Date.now() - lockStat.mtimeMs > OPERATION_LOCK_STALE_MS) {
-        await rm(lockPath, { recursive: true, force: true });
-        continue;
-      }
-      if (Date.now() >= deadline) {
-        throw new GithubExtensionError(`Timed out waiting for extension operation: ${id}`, {
-          code: "extension_operation_busy",
-          status: 409
-        });
-      }
-      await new Promise((resolve) => setTimeout(resolve, 30));
-    }
-  }
-  try {
-    return await operation();
-  } finally {
-    await rm(lockPath, { recursive: true, force: true });
-  }
-}
-function extensionSort(left, right) {
-  return left.id.localeCompare(right.id);
-}
-
-export {
-  createGithubExtensionManager
-};