opkg 0.9.2 → 0.9.4

package/packages/cli/dist/chunk-VQDTXLOX.js

@@ -0,0 +1,1312 @@
+#!/usr/bin/env node
+import {
+  createHttpClient
+} from "./chunk-6DITYAFA.js";
+import {
+  authManager
+} from "./chunk-C6FY55UP.js";
+import {
+  classifyInputBase
+} from "./chunk-AR7GJCG6.js";
+import {
+  classifyPackageInput
+} from "./chunk-OUZRMGPV.js";
+import {
+  walkFiles
+} from "./chunk-A6ISKBNM.js";
+import {
+  createWorkspacePackageYml,
+  ensureLocalOpenPackageStructure,
+  loadPackageFromPath,
+  packageManager
+} from "./chunk-D3O7LY2Q.js";
+import {
+  detectPluginType,
+  extractPackageFromTarball,
+  formatVersionLabel,
+  verifyTarballIntegrity
+} from "./chunk-HYKYECAE.js";
+import {
+  getLocalOpenPackageDir,
+  getLocalPackageYmlPath
+} from "./chunk-VXNS3X5O.js";
+import {
+  normalizeGitUrl
+} from "./chunk-WNRXZLWW.js";
+import {
+  resolveDeclaredPath
+} from "./chunk-FRYA3JAQ.js";
+import {
+  resolveOutput
+} from "./chunk-RAKMX654.js";
+import {
+  ensureRegistryDirectories,
+  getPackageVersionPath
+} from "./chunk-GDVFS3YP.js";
+import {
+  parsePackageYml
+} from "./chunk-427DCURL.js";
+import {
+  splitFrontmatter
+} from "./chunk-VQ2KY6CK.js";
+import {
+  normalizePlatforms
+} from "./chunk-N43IXOND.js";
+import {
+  normalizePathForProcessing
+} from "./chunk-YMKK4XPN.js";
+import {
+  DIR_PATTERNS,
+  FILE_PATTERNS,
+  PACKAGE_PATHS
+} from "./chunk-IHVZ5AUJ.js";
+import {
+  ensureDir,
+  exists,
+  readTextFile,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  ConfigError,
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/utils/resolution-mode.ts
+function determineResolutionMode(options) {
+  return options.resolutionMode ? options.resolutionMode : options.remote ? "remote-primary" : options.local ? "local-only" : "default";
+}
+
+// ../core/src/core/install/validators/options-validator.ts
+function validateResolutionFlags(options) {
+  if (options.remote && options.local)
+    throw new Error("--remote and --local cannot be used together. Choose one resolution mode.");
+}
+function validateConflictStrategy(strategy) {
+  if (!strategy) return;
+  let normalized = strategy.toLowerCase();
+  if (![
+    "namespace",
+    "overwrite",
+    "skip",
+    "ask"
+  ].includes(normalized))
+    throw new Error(
+      `Invalid --conflicts value '${strategy}'. Use one of: namespace, overwrite, skip, ask.`
+    );
+  return normalized;
+}
+
+// ../core/src/core/install/preprocessing/options-normalizer.ts
+function normalizePluginsOption(value) {
+  if (!value || value.length === 0)
+    return;
+  let plugins = [...new Set(value)];
+  return plugins.length > 0 ? plugins : void 0;
+}
+function normalizeInstallOptions(options) {
+  let platforms = normalizePlatforms(options.platforms), plugins = normalizePluginsOption(options.plugins), rawConflictStrategy = options.conflicts ?? options.conflictStrategy, conflictStrategy = validateConflictStrategy(rawConflictStrategy) ?? "namespace", resolutionMode = determineResolutionMode(options);
+  return {
+    ...options,
+    platforms,
+    plugins,
+    conflictStrategy,
+    resolutionMode,
+    agents: options.agents,
+    skills: options.skills,
+    rules: options.rules,
+    commands: options.commands,
+    interactive: options.interactive
+  };
+}
+
+// ../core/src/core/install/preprocessing/input-classifier.ts
+async function classifyInput(input, options, execContext) {
+  let hasConvenienceFilters = !!(options.agents?.length || options.skills?.length || options.rules?.length || options.commands?.length), base = await classifyInputBase(input, execContext.sourceCwd);
+  return enrichWithInstallFeatures(base, hasConvenienceFilters);
+}
+function enrichWithInstallFeatures(base, hasConvenienceFilters) {
+  let features = {
+    hasConvenienceFilters,
+    hasResourcePath: !1
+  };
+  switch (base.type) {
+    case "bulk":
+      return { type: "bulk", features };
+    case "git":
+      return {
+        type: "git",
+        gitUrl: base.gitUrl,
+        gitRef: base.gitRef,
+        resourcePath: base.gitPath,
+        features: {
+          ...features,
+          hasResourcePath: !!base.gitPath
+        }
+      };
+    case "local-path":
+      return {
+        type: "path",
+        localPath: base.absolutePath,
+        features
+      };
+    case "registry":
+      return {
+        type: "registry",
+        packageName: base.packageName,
+        version: base.version,
+        resourcePath: base.registryPath,
+        features: {
+          ...features,
+          hasResourcePath: !!base.registryPath
+        }
+      };
+  }
+}
+
+// ../core/src/core/install/preprocessing/base-resolver.ts
+import { join, relative } from "path";
+import { stat } from "fs/promises";
+async function resolveResourceScoping(repoRoot, baseAbs, resourcePath, options) {
+  let absResourcePath = join(repoRoot, resourcePath), rawRel = relative(baseAbs, absResourcePath).replace(/\\/g, "/");
+  if (rawRel.startsWith(".."))
+    return null;
+  let relToBaseRaw = rawRel.replace(/^\.\/?/, ""), isDirectory = !1;
+  try {
+    isDirectory = (await stat(absResourcePath)).isDirectory();
+  } catch {
+    if (options?.strict)
+      throw new ValidationError(
+        `The specified resource path does not exist in the repository: ${resourcePath}
+
+Please verify the path. The file or directory may have been moved, or you may have meant a different path.`
+      );
+  }
+  let prefix = relToBaseRaw.replace(/\/$/, ""), pattern = isDirectory ? prefix ? `${prefix}/**` : "**" : relToBaseRaw;
+  return { relPath: relToBaseRaw, isDirectory, pattern };
+}
+function applyBaseDetection(ctx, loaded) {
+  let baseDetection = loaded.sourceMetadata?.baseDetection;
+  if (!baseDetection)
+    return {};
+  if (ctx.source._baseDetectionPerformed)
+    return logger.debug("Base detection already applied, skipping redundant application"), {};
+  if (loaded.pluginMetadata?.pluginType === "marketplace")
+    return ctx.source._baseDetectionPerformed = !0, { specialHandling: "marketplace" };
+  baseDetection?.base && (ctx.detectedBase = baseDetection.base, ctx.source.detectedBase = baseDetection.base), baseDetection?.matchedPattern && !ctx.matchedPattern && (ctx.matchedPattern = baseDetection.matchedPattern), baseDetection?.matchType && (ctx.baseSource = baseDetection.matchType);
+  let effectiveContentRoot = ctx.detectedBase || loaded.contentRoot;
+  effectiveContentRoot && (ctx.source.contentRoot = effectiveContentRoot);
+  let repoRoot = loaded.sourceMetadata?.repoPath;
+  return !ctx.baseRelative && repoRoot && ctx.detectedBase ? ctx.baseRelative = relative(repoRoot, ctx.detectedBase) || "." : !ctx.baseRelative && loaded.contentRoot && ctx.detectedBase && (ctx.baseRelative = relative(loaded.contentRoot, ctx.detectedBase) || "."), ctx.source._baseDetectionPerformed = !0, baseDetection?.matchType === "marketplace" ? { specialHandling: "marketplace" } : baseDetection?.matchType === "ambiguous" && Array.isArray(baseDetection.ambiguousMatches) ? { specialHandling: "ambiguous", ambiguousMatches: baseDetection.ambiguousMatches } : {};
+}
+async function computePathScoping(ctx, loaded, resourcePath) {
+  if (ctx._pathScopingPerformed) {
+    logger.debug("Path scoping already computed, skipping redundant computation");
+    return;
+  }
+  let repoRoot = loaded.sourceMetadata?.repoPath || loaded.contentRoot;
+  if (!repoRoot)
+    return;
+  let baseAbs = ctx.detectedBase || loaded.contentRoot;
+  if (!baseAbs)
+    return;
+  let result = await resolveResourceScoping(repoRoot, baseAbs, resourcePath, { strict: !0 });
+  if (!result)
+    throw new ValidationError(
+      `The specified resource path is outside the package base: ${resourcePath}
+
+Please verify the path is within the package you are installing.`
+    );
+  ctx.matchedPattern = result.pattern, ctx._pathScopingPerformed = !0;
+}
+
+// ../core/src/core/install/preprocessing/convenience-preprocessor.ts
+import { join as join4 } from "path";
+
+// ../core/src/core/install/convenience-matchers.ts
+import { join as join2, basename, dirname, relative as relative2, resolve, sep } from "path";
+async function applyConvenienceFilters(basePath, repoRoot, options) {
+  let resources = [], errors = [], baseRoot = resolve(basePath), repoRootResolved = resolve(repoRoot), scopeRoots = options.pluginScope?.map((scope) => resolve(repoRootResolved, scope)) ?? [], isInScope = (absPath) => scopeRoots.length === 0 ? !0 : scopeRoots.some((scopeRoot) => absPath === scopeRoot ? !0 : absPath.startsWith(`${scopeRoot}${sep}`)), toRepoRelative = (absPath) => relative2(repoRootResolved, absPath).replace(/\\/g, "/").replace(/^\.\/?/, "");
+  if (options.agents && options.agents.length > 0) {
+    let agentResults = await matchMarkdownResources(basePath, "agents", "Agent", options.agents);
+    for (let result of agentResults)
+      if (result.found && result.path) {
+        let absPath = resolve(result.path);
+        if (!isInScope(absPath)) {
+          errors.push(`Agent '${result.name}' not found in selected plugin scope`);
+          continue;
+        }
+        let resourcePath = toRepoRelative(absPath);
+        resources.push({
+          name: result.name,
+          resourceType: "agent",
+          resourcePath,
+          basePath: baseRoot,
+          resourceKind: "file",
+          matchedBy: result.matchedBy || "filename",
+          resourceVersion: result.version
+        });
+      } else result.error && errors.push(result.error);
+  }
+  if (options.skills && options.skills.length > 0) {
+    let skillResults = await matchSkills(basePath, options.skills);
+    for (let result of skillResults)
+      if (result.found && result.path && result.installDir) {
+        let absDir = resolve(result.installDir);
+        if (!isInScope(absDir)) {
+          errors.push(`Skill '${result.name}' not found in selected plugin scope`);
+          continue;
+        }
+        let resourcePath = toRepoRelative(absDir);
+        resources.push({
+          name: result.name,
+          resourceType: "skill",
+          resourcePath,
+          basePath: baseRoot,
+          resourceKind: "directory",
+          matchedBy: result.matchedBy || "dirname",
+          resourceVersion: result.version
+        });
+      } else result.error && errors.push(result.error);
+  }
+  if (options.rules && options.rules.length > 0) {
+    let ruleResults = await matchMarkdownResources(basePath, "rules", "Rule", options.rules);
+    for (let result of ruleResults)
+      if (result.found && result.path) {
+        let absPath = resolve(result.path);
+        if (!isInScope(absPath)) {
+          errors.push(`Rule '${result.name}' not found in selected plugin scope`);
+          continue;
+        }
+        let resourcePath = toRepoRelative(absPath);
+        resources.push({
+          name: result.name,
+          resourceType: "rule",
+          resourcePath,
+          basePath: baseRoot,
+          resourceKind: "file",
+          matchedBy: result.matchedBy || "filename",
+          resourceVersion: result.version
+        });
+      } else result.error && errors.push(result.error);
+  }
+  if (options.commands && options.commands.length > 0) {
+    let commandResults = await matchMarkdownResources(basePath, "commands", "Command", options.commands);
+    for (let result of commandResults)
+      if (result.found && result.path) {
+        let absPath = resolve(result.path);
+        if (!isInScope(absPath)) {
+          errors.push(`Command '${result.name}' not found in selected plugin scope`);
+          continue;
+        }
+        let resourcePath = toRepoRelative(absPath);
+        resources.push({
+          name: result.name,
+          resourceType: "command",
+          resourcePath,
+          basePath: baseRoot,
+          resourceKind: "file",
+          matchedBy: result.matchedBy || "filename",
+          resourceVersion: result.version
+        });
+      } else result.error && errors.push(result.error);
+  }
+  return logger.info("Convenience filter results", {
+    resourceCount: resources.length,
+    errorCount: errors.length
+  }), {
+    resources,
+    errors
+  };
+}
+async function matchMarkdownResources(basePath, subDir, resourceLabel, requestedNames) {
+  let results = [], dir = join2(basePath, subDir), files = [];
+  if (await exists(dir))
+    for await (let file of walkFiles(dir))
+      file.endsWith(".md") && files.push(file);
+  for (let name of requestedNames) {
+    let match = await findMarkdownResourceByName(files, name);
+    match ? results.push({
+      name,
+      found: !0,
+      path: match.path,
+      matchedBy: match.matchedBy,
+      version: match.version
+    }) : results.push({
+      name,
+      found: !1,
+      error: `${resourceLabel} '${name}' not found`
+    });
+  }
+  return results;
+}
+async function findMarkdownResourceByName(files, name) {
+  for (let file of files)
+    try {
+      let content = await readTextFile(file), { frontmatter } = splitFrontmatter(content);
+      if (frontmatter?.name === name) {
+        let version = extractVersionFromFrontmatter(frontmatter);
+        return { path: file, matchedBy: "frontmatter", version };
+      }
+    } catch {
+    }
+  let byFilename = files.filter((f) => basename(f, ".md") === name);
+  if (byFilename.length === 1) {
+    let file = byFilename[0], version = await extractVersionFromFile(file);
+    return { path: file, matchedBy: "filename", version };
+  }
+  if (byFilename.length > 1) {
+    let deepest = byFilename.sort(
+      (a, b) => b.split("/").length - a.split("/").length
+    )[0], version = await extractVersionFromFile(deepest);
+    return { path: deepest, matchedBy: "filename", version };
+  }
+  return null;
+}
+async function matchSkills(basePath, requestedNames) {
+  let results = [], skillsDir = join2(basePath, "skills"), skillFiles = [];
+  if (await exists(skillsDir))
+    for await (let file of walkFiles(skillsDir))
+      basename(file) === "SKILL.md" && skillFiles.push(file);
+  for (let name of requestedNames) {
+    let match = await findSkillByName(skillFiles, name);
+    match ? results.push({
+      name,
+      found: !0,
+      path: match.path,
+      installDir: dirname(match.path),
+      // Install entire parent directory
+      matchedBy: match.matchedBy,
+      version: match.version
+    }) : results.push({
+      name,
+      found: !1,
+      error: `Skill '${name}' not found (requires SKILL.md)`
+    });
+  }
+  return results;
+}
+async function findSkillByName(skillFiles, name) {
+  for (let file of skillFiles)
+    try {
+      let content = await readTextFile(file), { frontmatter } = splitFrontmatter(content);
+      if (frontmatter?.name === name) {
+        let version = extractVersionFromFrontmatter(frontmatter);
+        return { path: file, matchedBy: "frontmatter", version };
+      }
+    } catch {
+    }
+  for (let file of skillFiles)
+    if (basename(dirname(file)) === name) {
+      let version = await extractVersionFromFile(file);
+      return { path: file, matchedBy: "dirname", version };
+    }
+  let matchingByNested = skillFiles.filter((file) => dirname(file).split("/").includes(name));
+  if (matchingByNested.length > 0) {
+    let deepest = matchingByNested.sort(
+      (a, b) => b.split("/").length - a.split("/").length
+    )[0], version = await extractVersionFromFile(deepest);
+    return { path: deepest, matchedBy: "dirname", version };
+  }
+  return null;
+}
+function displayFilterErrors(errors, output) {
+  if (errors.length === 0)
+    return;
+  let out = output ?? resolveOutput();
+  out.error(`
+The following resources were not found:`);
+  for (let error of errors)
+    out.error(`  - ${error}`);
+}
+function extractVersionFromFrontmatter(frontmatter) {
+  if (!frontmatter || typeof frontmatter != "object")
+    return;
+  let version = frontmatter.version ?? frontmatter.metadata?.version;
+  if (typeof version == "string") {
+    let trimmed = version.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+}
+async function extractVersionFromFile(filePath) {
+  try {
+    let content = await readTextFile(filePath), { frontmatter } = splitFrontmatter(content);
+    return extractVersionFromFrontmatter(frontmatter);
+  } catch {
+    return;
+  }
+}
+
+// ../core/src/core/install/unified/context-builders.ts
+import { basename as basename2, join as join3, relative as relative3 } from "path";
+async function buildRegistryInstallContext(execContext, packageName, options) {
+  let source = {
+    type: "registry",
+    packageName,
+    version: options.version,
+    registryPath: options.registryPath
+  };
+  return {
+    execution: execContext,
+    targetDir: execContext.targetDir,
+    source,
+    mode: "install",
+    options,
+    platforms: normalizePlatforms(options.platforms) || [],
+    resolvedPackages: [],
+    warnings: [],
+    errors: []
+  };
+}
+async function buildPathInstallContext(execContext, sourcePath, options) {
+  let source = {
+    type: "path",
+    packageName: "",
+    // Populated after loading
+    localPath: sourcePath,
+    sourceType: options.sourceType
+  };
+  return {
+    execution: execContext,
+    targetDir: execContext.targetDir,
+    source,
+    mode: "install",
+    options,
+    platforms: normalizePlatforms(options.platforms) || [],
+    resolvedPackages: [],
+    warnings: [],
+    errors: []
+  };
+}
+async function buildGitInstallContext(execContext, gitUrl, options) {
+  let source = {
+    type: "git",
+    packageName: "",
+    // Populated after loading
+    gitUrl,
+    gitRef: options.gitRef,
+    gitPath: options.gitPath
+  };
+  return {
+    execution: execContext,
+    targetDir: execContext.targetDir,
+    source,
+    mode: "install",
+    options,
+    platforms: normalizePlatforms(options.platforms) || [],
+    resolvedPackages: [],
+    warnings: [],
+    errors: []
+  };
+}
+async function buildWorkspaceRootInstallContext(execContext, options, mode = "install") {
+  let cwd = execContext.targetDir;
+  await ensureLocalOpenPackageStructure(cwd), await createWorkspacePackageYml(cwd);
+  let openpackageDir = getLocalOpenPackageDir(cwd), packageYmlPath = getLocalPackageYmlPath(cwd);
+  if (!await exists(packageYmlPath))
+    return null;
+  let config;
+  try {
+    config = await parsePackageYml(packageYmlPath);
+  } catch (error) {
+    return logger.warn(`Failed to read workspace manifest: ${error}`), null;
+  }
+  let source = {
+    type: "workspace",
+    packageName: config.name || basename2(cwd),
+    version: config.version,
+    contentRoot: openpackageDir
+  };
+  return {
+    execution: execContext,
+    targetDir: execContext.targetDir,
+    source,
+    mode,
+    options: mode === "apply" ? { ...options, force: !0 } : options,
+    platforms: normalizePlatforms(options.platforms) || [],
+    resolvedPackages: [],
+    warnings: [],
+    errors: []
+  };
+}
+async function buildInstallContext(execContext, packageInput, options) {
+  if (!packageInput)
+    return buildBulkInstallContexts(execContext, options);
+  let classification = await classifyPackageInput(packageInput, execContext.sourceCwd);
+  switch (classification.type) {
+    case "registry":
+      return buildRegistryInstallContext(execContext, classification.name, options);
+    case "directory":
+    case "tarball":
+      return buildPathInstallContext(execContext, classification.resolvedPath, {
+        ...options,
+        sourceType: classification.type
+      });
+    case "git":
+      return buildGitInstallContext(execContext, classification.gitUrl, {
+        ...options,
+        gitRef: classification.gitRef,
+        gitPath: classification.gitPath
+      });
+    default:
+      throw new Error(`Unknown package input type: ${classification.type}`);
+  }
+}
+async function buildBulkInstallContexts(execContext, options) {
+  let cwd = execContext.targetDir, dependencyContexts = [], workspaceContext = await buildWorkspaceRootInstallContext(execContext, options, "install");
+  await createWorkspacePackageYml(cwd);
+  let opkgYmlPath = getLocalPackageYmlPath(cwd), opkgYml = await parsePackageYml(opkgYmlPath), workspacePackageName = workspaceContext?.source.packageName, deps = opkgYml.packages ?? opkgYml.dependencies ?? [], devDeps = opkgYml.devDependencies ?? opkgYml["dev-dependencies"] ?? [], allDeps = [...deps, ...devDeps].filter(Boolean), seen = /* @__PURE__ */ new Set();
+  if (allDeps.length > 0)
+    for (let dep of allDeps) {
+      let dedupeKey = JSON.stringify({
+        name: dep?.name ?? null,
+        url: dep?.url ?? dep?.git ?? null,
+        ref: dep?.ref ?? null,
+        path: dep?.path ?? null,
+        version: dep?.version ?? null,
+        base: dep?.base ?? null
+      });
+      if (seen.has(dedupeKey) || (seen.add(dedupeKey), workspacePackageName && dep.name === workspacePackageName))
+        continue;
+      let source;
+      if (dep.git || dep.url) {
+        let gitUrlRaw = dep.url || dep.git, [gitUrl, embeddedRef] = gitUrlRaw.includes("#") ? gitUrlRaw.split("#", 2) : [gitUrlRaw, void 0], gitRef = embeddedRef || dep.ref, resourcePathFromName, depName = String(dep.name ?? "");
+        if (depName.startsWith("gh@")) {
+          let parts = depName.slice(3).split("/").filter(Boolean);
+          parts.length > 2 && (resourcePathFromName = parts.slice(2).join("/"));
+        }
+        let effectiveResourcePath = dep.path || resourcePathFromName, shouldTreatPathAsResource = depName.startsWith("gh@");
+        source = {
+          type: "git",
+          packageName: dep.name,
+          gitUrl,
+          gitRef,
+          gitPath: shouldTreatPathAsResource ? void 0 : dep.path,
+          resourcePath: shouldTreatPathAsResource ? effectiveResourcePath : void 0,
+          manifestBase: dep.base
+          // Phase 5: Pass manifest base to source
+        };
+      } else if (dep.path) {
+        let resolved = resolveDeclaredPath(dep.path, cwd), isTarball = dep.path.endsWith(".tgz") || dep.path.endsWith(".tar.gz");
+        source = {
+          type: "path",
+          packageName: dep.name,
+          localPath: resolved.absolute,
+          sourceType: isTarball ? "tarball" : "directory",
+          manifestBase: dep.base
+          // Phase 5: Pass manifest base to source
+        };
+      } else
+        source = {
+          type: "registry",
+          packageName: dep.name,
+          version: dep.version,
+          manifestBase: dep.base
+          // Phase 5: Pass manifest base to source
+        };
+      let context = {
+        execution: execContext,
+        targetDir: execContext.targetDir,
+        source,
+        mode: "install",
+        options,
+        platforms: normalizePlatforms(options.platforms) || [],
+        resolvedPackages: [],
+        warnings: [],
+        errors: []
+      };
+      dep.base && (context.baseRelative = dep.base, context.baseSource = "manifest"), dependencyContexts.push(context);
+    }
+  return { workspaceContext: workspaceContext ?? null, dependencyContexts };
+}
+function buildResourceMatchedPattern(resourceSpec, repoRoot, basePath) {
+  let absoluteResourcePath = join3(repoRoot, resourceSpec.resourcePath), relativeToBase = relative3(basePath, absoluteResourcePath).replace(/\\/g, "/").replace(/^\.\/?/, "");
+  if (relativeToBase)
+    return resourceSpec.resourceKind === "directory" ? `${relativeToBase.replace(/\/$/, "")}/**` : relativeToBase;
+}
+function prepareResourceContextsForMultiInstall(contexts, repoRoot) {
+  return contexts.map((rc) => (rc.source.type === "path" && (rc.source.localPath = repoRoot), rc));
+}
+function buildResourceInstallContexts(baseContext, resourceSpecs, repoRoot) {
+  let detectedBase = baseContext.detectedBase ?? baseContext.source.contentRoot ?? baseContext.targetDir, baseRelative = baseContext.baseRelative ?? (relative3(repoRoot, detectedBase) || ".");
+  return resourceSpecs.map((spec) => {
+    let effectiveBase = baseContext.detectedBase ?? spec.basePath, matchedPattern = buildResourceMatchedPattern(spec, repoRoot, effectiveBase) ?? baseContext.matchedPattern, isSingleFile = !!(matchedPattern && !matchedPattern.includes("*") && !matchedPattern.includes("?") && !matchedPattern.includes("[")), baseName = baseContext.source.packageName, scopedName = isSingleFile ? `${baseName}/${matchedPattern}` : baseName, source = {
+      ...baseContext.source,
+      packageName: scopedName,
+      resourcePath: spec.resourcePath,
+      resourceVersion: spec.resourceVersion
+    }, resolvedPackages = baseContext.resolvedPackages;
+    return isSingleFile && baseContext.resolvedPackages.length > 0 ? resolvedPackages = baseContext.resolvedPackages.map((pkg) => ({
+      ...pkg,
+      name: pkg.isRoot ? scopedName : pkg.name
+    })) : baseContext.resolvedPackages.length === 0 && (resolvedPackages = []), {
+      ...baseContext,
+      source,
+      resolvedPackages,
+      warnings: [],
+      errors: [],
+      detectedBase: effectiveBase,
+      baseRelative: baseRelative === "" ? "." : baseRelative,
+      baseSource: baseContext.baseSource,
+      matchedPattern
+    };
+  });
+}
+
+// ../core/src/core/install/preprocessing/convenience-preprocessor.ts
+async function findBaseForConvenienceFilters(contentRoot, options) {
+  let candidates = [contentRoot];
+  for (let sub of [".opencode", ".cursor", ".claude", ".claude-plugin"])
+    candidates.push(join4(contentRoot, sub));
+  for (let base of candidates)
+    if (options.agents?.length && await exists(join4(base, "agents")) || options.skills?.length && await exists(join4(base, "skills")) || options.rules?.length && await exists(join4(base, "rules")) || options.commands?.length && await exists(join4(base, "commands"))) return base;
+  return contentRoot;
+}
+async function resolveConvenienceResources(basePath, repoRoot, options) {
+  let filterResult = await applyConvenienceFilters(basePath, repoRoot, options);
+  if (filterResult.errors.length > 0) {
+    if (displayFilterErrors(filterResult.errors), filterResult.resources.length === 0)
+      throw new Error("None of the requested resources were found");
+    logger.debug(`Continuing with ${filterResult.resources.length} resource(s)`);
+  }
+  return filterResult.resources;
+}
+async function runConvenienceFilterInstall(context, loaded, options, opts) {
+  let contentRoot = loaded.contentRoot, repoRoot = loaded.sourceMetadata?.repoPath ?? contentRoot, basePath = opts?.useDetectedBase && context.detectedBase ? context.detectedBase : await findBaseForConvenienceFilters(contentRoot, options), resources = await resolveConvenienceResources(basePath, repoRoot, options), resourceContexts = buildResourceInstallContexts(context, resources, repoRoot);
+  return prepareResourceContextsForMultiInstall(resourceContexts, repoRoot);
+}
+
+// ../core/src/core/remote-pull.ts
+import * as yaml2 from "js-yaml";
+
+// ../core/src/utils/manifest-paths.ts
+function normalizePackagePath(path) {
+  let trimmed = path.startsWith("/") ? path.slice(1) : path;
+  return normalizePathForProcessing(trimmed);
+}
+function isManifestPath(path) {
+  let normalized = normalizePackagePath(path);
+  return normalized === FILE_PATTERNS.OPENPACKAGE_YML || normalized === PACKAGE_PATHS.MANIFEST_RELATIVE;
+}
+
+// ../core/src/core/platform/registry-entry-filter.ts
+function normalizeRegistryPath(registryPath) {
+  return normalizePathForProcessing(registryPath);
+}
+
+// ../core/src/utils/package-merge.ts
+import * as yaml from "js-yaml";
+var PACKAGE_INDEX = normalizePathForProcessing(PACKAGE_PATHS.INDEX_RELATIVE);
+function mergePackageFiles(base, incoming) {
+  let byPath = /* @__PURE__ */ new Map(), addAll = (list) => {
+    for (let file of list) {
+      let normalized = normalizePathForProcessing(file.path) || file.path;
+      normalized !== PACKAGE_INDEX && byPath.set(normalized, { ...file, path: normalized });
+    }
+  };
+  return addAll(base), addAll(incoming), Array.from(byPath.values());
+}
+
+// ../core/src/core/cache-manager.ts
+import { homedir as homedir2 } from "os";
+import { join as join6 } from "path";
+
+// ../core/src/utils/git-cache.ts
+import { createHash } from "crypto";
+import { join as join5, basename as basename3 } from "path";
+import { homedir } from "os";
+function computeGitUrlHash(url) {
+  let normalized = normalizeGitUrl(url);
+  return createHash("sha256").update(normalized).digest("hex").substring(0, 12);
+}
+function getGitCacheDir() {
+  return join5(homedir(), ".openpackage", "cache", "git");
+}
+function getGitRepoCacheDir(url) {
+  let urlHash = computeGitUrlHash(url), cacheDir = getGitCacheDir();
+  return join5(cacheDir, urlHash);
+}
+function getGitCommitCacheDir(url, commitSha) {
+  let repoDir = getGitRepoCacheDir(url), shortSha = commitSha.substring(0, 7);
+  return join5(repoDir, shortSha);
+}
+function getRepoMetadataPath(repoDir) {
+  return join5(repoDir, ".opkg-repo.json");
+}
+function getCommitMetadataPath(commitDir) {
+  return join5(commitDir, ".opkg-commit.json");
+}
+async function writeRepoMetadata(repoDir, metadata) {
+  let metaPath = getRepoMetadataPath(repoDir);
+  await ensureDir(repoDir), await writeTextFile(metaPath, JSON.stringify(metadata, null, 2));
+}
+async function writeCommitMetadata(commitDir, metadata) {
+  let metaPath = getCommitMetadataPath(commitDir);
+  await ensureDir(commitDir), await writeTextFile(metaPath, JSON.stringify(metadata, null, 2));
+}
+async function readCommitMetadata(commitDir) {
+  let metaPath = getCommitMetadataPath(commitDir);
+  if (!await exists(metaPath))
+    return null;
+  try {
+    let content = await readTextFile(metaPath);
+    return JSON.parse(content);
+  } catch (error) {
+    return logger.warn(`Failed to read commit metadata at ${metaPath}`, { error }), null;
+  }
+}
+async function touchCacheEntry(commitDir) {
+  let metadata = await readCommitMetadata(commitDir);
+  metadata && (metadata.lastAccessed = (/* @__PURE__ */ new Date()).toISOString(), await writeCommitMetadata(commitDir, metadata));
+}
+async function isCommitCached(url, commitSha) {
+  let commitDir = getGitCommitCacheDir(url, commitSha);
+  return await exists(commitDir);
+}
+
+// ../core/src/core/cache-manager.ts
+var METADATA_TTL_MS = 600 * 1e3;
+function getGitRefsCacheDir() {
+  return join6(homedir2(), ".openpackage", "cache", "git-refs");
+}
+function getMetadataCacheDir() {
+  return join6(homedir2(), ".openpackage", "cache", "metadata");
+}
+function getGitRefCachePath(url) {
+  let urlHash = computeGitUrlHash(url);
+  return join6(getGitRefsCacheDir(), `${urlHash}.json`);
+}
+function getMetadataCachePath(name) {
+  let safeName = name.replace(/\//g, "__");
+  return join6(getMetadataCacheDir(), `${safeName}.json`);
+}
+function isExpired(fetchedAt, ttlMs) {
+  let fetchedTime = new Date(fetchedAt).getTime();
+  return Date.now() - fetchedTime > ttlMs;
+}
+async function readJsonFile(filePath) {
+  if (!await exists(filePath))
+    return null;
+  try {
+    let content = await readTextFile(filePath);
+    return JSON.parse(content);
+  } catch (error) {
+    return logger.warn(`Failed to read cache file at ${filePath}`, { error }), null;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  let dir = join6(filePath, "..");
+  await ensureDir(dir), await writeTextFile(filePath, JSON.stringify(data, null, 2));
+}
+function createCacheManager() {
+  return {
+    async getCachedCommitForRef(url, ref) {
+      let cachePath = getGitRefCachePath(url), cache = await readJsonFile(cachePath);
+      return cache?.refs?.[ref] ? cache.refs[ref].commit : null;
+    },
+    async cacheRefCommit(url, ref, commit) {
+      let cachePath = getGitRefCachePath(url), cache = await readJsonFile(cachePath);
+      cache || (cache = { refs: {} }), cache.refs[ref] = {
+        commit,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }, await writeJsonFile(cachePath, cache), logger.debug(`Cached git ref ${ref} -> ${commit.substring(0, 7)}`, { url });
+    },
+    async getLocalPackagePath(name, version) {
+      let packagePath = getPackageVersionPath(name, version);
+      return await exists(packagePath) ? packagePath : null;
+    },
+    async hasLocalPackage(name, version) {
+      let packagePath = getPackageVersionPath(name, version);
+      return await exists(packagePath);
+    },
+    async getCachedMetadata(name) {
+      let cachePath = getMetadataCachePath(name), cache = await readJsonFile(cachePath);
+      return cache ? isExpired(cache.fetchedAt, METADATA_TTL_MS) ? (logger.debug(`Metadata cache expired for ${name}`, { fetchedAt: cache.fetchedAt }), null) : cache : null;
+    },
+    async cacheMetadata(name, versions, etag) {
+      let cachePath = getMetadataCachePath(name), cache = {
+        versions,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...etag && { etag }
+      };
+      await writeJsonFile(cachePath, cache), logger.debug(`Cached metadata for ${name}`, { versionCount: versions.length });
+    }
+  };
+}
+
+// ../core/src/core/remote-pull.ts
+var NETWORK_ERROR_PATTERN = /(fetch failed|ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|network)/i;
+function matchesNetworkPattern(value) {
+  return typeof value == "string" && NETWORK_ERROR_PATTERN.test(value);
+}
+function isNetworkFailure(error) {
+  if (matchesNetworkPattern(error.message))
+    return !0;
+  let cause = error.cause;
+  return !!(cause && (matchesNetworkPattern(cause.message) || matchesNetworkPattern(cause.code) || matchesNetworkPattern(cause.errno)) || matchesNetworkPattern(error.code) || matchesNetworkPattern(error.errno));
+}
+function normalizeDownloadPaths(paths) {
+  if (!paths || paths.length === 0)
+    return [];
+  let normalized = paths.filter((path) => typeof path == "string").map((path) => path.startsWith("/") ? path.slice(1) : path).map((path) => normalizeRegistryPath(path)).filter((path) => path.length > 0);
+  return Array.from(new Set(normalized));
+}
+function buildPullEndpoint(name, version, options) {
+  let encodedName = encodeURIComponent(name), endpoint = version && version !== "latest" ? `/packages/pull/by-name/${encodedName}/v/${encodeURIComponent(version)}` : `/packages/pull/by-name/${encodedName}`, params = [];
+  options?.recursive && params.push("recursive=true");
+  let normalizedPaths = normalizeDownloadPaths(options?.paths);
+  if (normalizedPaths.length > 0) {
+    let encodedPaths = normalizedPaths.map((path) => encodeURIComponent(path)).join(",");
+    params.push(`paths=${encodedPaths}`), params.push("includeManifest=true");
+  }
+  if (params.length === 0)
+    return endpoint;
+  let delimiter = endpoint.includes("?") ? "&" : "?";
+  return `${endpoint}${delimiter}${params.join("&")}`;
+}
+function parseDownloadIdentifier(downloadName) {
+  let atIndex = -1;
+  if (downloadName.startsWith("gh@")) {
+    for (let i = downloadName.length - 1; i >= 0; i--)
+      if (downloadName[i] === "@" && i !== 2) {
+        atIndex = i;
+        break;
+      }
+  } else
+    atIndex = downloadName.lastIndexOf("@");
+  if (atIndex <= 0 || atIndex === downloadName.length - 1)
+    throw new Error(`Invalid download name '${downloadName}'. Expected format '<package>@<version>'.`);
+  let rawName = downloadName.slice(0, atIndex), rawVersion = downloadName.slice(atIndex + 1), packageName, namePath;
+  if (rawName.startsWith("gh@")) {
+    let segments = rawName.split("/");
+    if (segments.length < 2)
+      throw new Error(`Invalid GitHub package in download name '${downloadName}'.`);
+    packageName = segments.slice(0, 2).join("/"), segments.length > 2 && (namePath = segments.slice(2).join("/"));
+  } else if (rawName.startsWith("@")) {
+    let segments = rawName.split("/");
+    if (segments.length < 2)
+      throw new Error(`Invalid scoped package in download name '${downloadName}'.`);
+    packageName = segments.slice(0, 2).join("/"), namePath = segments.length > 2 ? segments.slice(2).join("/") : void 0;
+  } else {
+    let segments = rawName.split("/");
+    packageName = segments[0], namePath = segments.length > 1 ? segments.slice(1).join("/") : void 0;
+  }
+  let versionSegments = rawVersion.split("/"), version = versionSegments[0], versionPath = versionSegments.length > 1 ? versionSegments.slice(1).join("/") : void 0;
+  if (!packageName || !version)
+    throw new Error(`Invalid download name '${downloadName}'. Expected format '<package>@<version>'.`);
+  let registryPathParts = [namePath, versionPath].filter(Boolean), registryPath = registryPathParts.length > 0 ? registryPathParts.join("/") : void 0;
+  return { packageName, version, registryPath };
+}
+function isPartialDownload(download) {
+  return !1;
+}
+async function fetchRemotePackageMetadata(name, version, options = {}) {
+  try {
+    await ensureRegistryDirectories();
+    let context = await createContext(options), response = await getRemotePackage(
+      context.httpClient,
+      name,
+      version,
+      options.recursive,
+      options.paths
+    );
+    return {
+      success: !0,
+      context,
+      response
+    };
+  } catch (error) {
+    return mapErrorToFailure(error);
+  }
+}
+async function pullPackageFromRemote(name, version, options = {}) {
+  try {
+    if (version && version !== "latest" && !options.skipLocalCheck) {
+      let localPath = await createCacheManager().getLocalPackagePath(name, version);
+      if (localPath)
+        return logger.debug("Package already exists in local registry, skipping remote pull", { name, version, localPath }), {
+          success: !0,
+          name,
+          version,
+          response: {},
+          extracted: { files: [], checksum: "" },
+          registryUrl: "",
+          profile: "",
+          downloadUrl: "",
+          tarballSize: void 0
+        };
+    }
+    let metadataResult = options.preFetchedResponse ? await createResultFromPrefetched(options) : await fetchRemotePackageMetadata(name, version, options);
+    if (!metadataResult.success)
+      return metadataResult;
+    let { context, response } = metadataResult, primaryDownload = resolvePrimaryDownload(response);
+    if (!primaryDownload?.downloadUrl)
+      return {
+        success: !1,
+        reason: "access-denied",
+        message: "Package download not available for this account"
+      };
+    let isPartial = isPartialDownload(primaryDownload), tarballBuffer = await downloadPackageTarball(context.httpClient, primaryDownload.downloadUrl), expectedSize = isPartial ? void 0 : response.version.tarballSize;
+    if (!verifyTarballIntegrity(tarballBuffer, expectedSize))
+      return {
+        success: !1,
+        reason: "integrity",
+        message: "Tarball integrity verification failed"
+      };
+    let extracted = await extractPackageFromTarball(tarballBuffer);
+    return await savePackageToLocalRegistry(response, extracted, {
+      partial: isPartial
+    }), {
+      success: !0,
+      name: response.package.name,
+      version: formatVersionLabel(response.version.version),
+      response,
+      extracted,
+      registryUrl: context.registryUrl,
+      profile: context.profile,
+      downloadUrl: primaryDownload.downloadUrl,
+      tarballSize: response.version.tarballSize
+    };
+  } catch (error) {
+    return mapErrorToFailure(error);
+  }
+}
+function resolvePrimaryDownload(response) {
+  if (!Array.isArray(response.downloads) || response.downloads.length === 0)
+    return;
+  let primaryMatch = response.downloads.find((download) => download.name === response.package.name && download.downloadUrl);
+  return primaryMatch?.downloadUrl ? primaryMatch : response.downloads.find((download) => download.downloadUrl);
+}
+async function createResultFromPrefetched(options) {
+  if (!options.preFetchedResponse)
+    throw new Error("preFetchedResponse missing from options");
+  return {
+    success: !0,
+    context: await createContext(options),
+    response: options.preFetchedResponse
+  };
+}
+async function createContext(options) {
+  let authOptions = {
+    profile: options.profile,
+    apiKey: options.apiKey
+  }, httpClient = options.httpClient || await createHttpClient(authOptions), profile = authManager.getCurrentProfile(authOptions), registryUrl = authManager.getRegistryUrl();
+  return {
+    httpClient,
+    profile,
+    registryUrl
+  };
+}
+async function getRemotePackage(httpClient, name, version, recursive, paths) {
+  let finalEndpoint = buildPullEndpoint(name, version, { recursive, paths });
+  return logger.debug("Fetching remote package metadata", {
+    name,
+    version: version ?? "latest",
+    endpoint: finalEndpoint,
+    recursive: !!recursive,
+    hasPaths: !!paths && paths.length > 0
+  }), await httpClient.get(finalEndpoint);
+}
+async function downloadPackageTarball(httpClient, downloadUrl) {
+  let downloadHost = (() => {
+    try {
+      return new URL(downloadUrl).host;
+    } catch {
+      return "";
+    }
+  })(), registryHost = (() => {
+    try {
+      return new URL(authManager.getRegistryUrl()).host;
+    } catch {
+      return "";
+    }
+  })(), shouldSkipAuth = downloadHost !== "" && registryHost !== "" && downloadHost !== registryHost, buffer = await httpClient.downloadFile(downloadUrl, { skipAuth: shouldSkipAuth });
+  return Buffer.from(buffer);
+}
+async function savePackageToLocalRegistry(response, extracted, saveOptions = {}) {
+  let metadata = {
+    name: response.package.name,
+    version: response.version.version,
+    description: response.package.description,
+    keywords: response.package.keywords,
+    private: response.package.isPrivate
+  };
+  metadata.files = extracted.files.map((file) => file.path), metadata.created = response.version.createdAt, metadata.updated = response.version.updatedAt;
+  let files = extracted.files;
+  if (saveOptions.partial)
+    try {
+      let existing = await packageManager.loadPackage(response.package.name, response.version.version);
+      files = mergePackageFiles(existing.files, files);
+    } catch {
+    }
+  await packageManager.savePackage(
+    { metadata, files },
+    { partial: !!saveOptions.partial }
+  );
+}
+function mapErrorToFailure(error) {
+  if (logger.debug("Remote pull operation failed", { error }), error instanceof ValidationError)
+    return {
+      success: !1,
+      reason: "integrity",
+      message: error.message,
+      error
+    };
+  if (error instanceof ConfigError)
+    return {
+      success: !1,
+      reason: "access-denied",
+      message: error.message,
+      error
+    };
+  if (error instanceof Error) {
+    let apiError = error.apiError;
+    return apiError?.statusCode === 404 ? {
+      success: !1,
+      reason: "not-found",
+      message: error.message,
+      statusCode: 404,
+      error
+    } : apiError?.statusCode === 401 || apiError?.statusCode === 403 ? {
+      success: !1,
+      reason: "access-denied",
+      message: error.message,
+      statusCode: apiError.statusCode,
+      error
+    } : isNetworkFailure(error) ? {
+      success: !1,
+      reason: "network",
+      message: error.message,
+      error
+    } : {
+      success: !1,
+      reason: "unknown",
+      message: error.message,
+      error
+    };
+  }
+  return {
+    success: !1,
+    reason: "unknown",
+    message: "Unknown error occurred",
+    error
+  };
+}
+
+// ../core/src/core/git-clone.ts
+import { execFile } from "child_process";
+import { join as join7 } from "path";
+import { promisify } from "util";
+import { rm, rename } from "fs/promises";
+var GitSpinner = class {
+  constructor(message) {
+    this.message = message;
+  }
+  start() {
+    logger.debug(this.message);
+  }
+  update(text) {
+    this.message = text, logger.debug(text);
+  }
+  stop() {
+  }
+}, execFileAsync = promisify(execFile), cacheManager = createCacheManager();
+function isSha(ref) {
+  return /^[0-9a-f]{7,40}$/i.test(ref);
+}
+function isFullSha(ref) {
+  return /^[0-9a-f]{40}$/i.test(ref);
+}
+async function runGit(args, cwd) {
+  try {
+    return (await execFileAsync("git", args, { cwd })).stdout.trim();
+  } catch (error) {
+    let message = error?.stderr?.toString?.().trim?.() || error?.message || String(error);
+    throw new ValidationError(`Git command failed: ${message}`);
+  }
+}
+async function getCurrentCommitSha(repoPath) {
+  return (await runGit(["rev-parse", "HEAD"], repoPath)).substring(0, 7);
+}
+async function resolveRefWithLsRemote(url, ref) {
+  try {
+    let output = await runGit(["ls-remote", url, ref || "HEAD"]);
+    if (!output)
+      return null;
+    let match = output.match(/^([0-9a-f]{40})\s/i);
+    return match ? match[1].substring(0, 7) : null;
+  } catch {
+    return null;
+  }
+}
+var SEMVER_TAG_PATTERN = /^v?\d+\.\d+\.\d+(?:[-+].*)?$/;
+function isImmutableRef(ref) {
+  return isFullSha(ref) || SEMVER_TAG_PATTERN.test(ref);
+}
+async function cloneRepoToCache(options) {
+  let { url, ref, subdir, skipCache } = options, getDisplayUrl = () => {
+    let match = url.match(/([^/]+\/[^/]+?)(?:\.git)?$/);
+    return match ? match[1] : url;
+  }, tryCache = async (shortSha, source) => {
+    if (await isCommitCached(url, shortSha)) {
+      let commitDir = getGitCommitCacheDir(url, shortSha);
+      await touchCacheEntry(commitDir);
+      let finalPath = subdir ? join7(commitDir, subdir) : commitDir;
+      if (!subdir || await exists(finalPath)) {
+        logger.debug(`Using cached commit (${source})`, { url, ref, commit: shortSha });
+        let refDisplay2 = ref ? `#${ref}` : "", subdirDisplay = subdir ? `/${subdir}` : "";
+        return logger.info(`Using cached ${getDisplayUrl()}${refDisplay2}${subdirDisplay} [${shortSha}]`), { path: finalPath, commitSha: shortSha, repoPath: commitDir };
+      }
+    }
+    return null;
+  };
+  if (!skipCache) {
+    if (ref && isFullSha(ref)) {
+      let shortSha = ref.substring(0, 7), cached = await tryCache(shortSha, "full SHA");
+      if (cached) return cached;
+    }
+    if (ref && isImmutableRef(ref) && !isFullSha(ref)) {
+      let cachedCommit = await cacheManager.getCachedCommitForRef(url, ref);
+      if (cachedCommit) {
+        let cached = await tryCache(cachedCommit, "immutable ref cache");
+        if (cached) return cached;
+      }
+    }
+    let refDisplay2 = ref ? `#${ref}` : "", spinner2 = new GitSpinner(`Checking ${getDisplayUrl()}${refDisplay2}`);
+    spinner2.start();
+    let resolvedSha = await resolveRefWithLsRemote(url, ref);
+    if (spinner2.stop(), resolvedSha) {
+      ref && await cacheManager.cacheRefCommit(url, ref, resolvedSha);
+      let cached = await tryCache(resolvedSha, "ls-remote");
+      if (cached) return cached;
+      logger.debug("Commit not cached, will clone", { url, ref, resolvedSha });
+    }
+  }
+  let repoDir = getGitRepoCacheDir(url);
+  await ensureDir(repoDir), await writeRepoMetadata(repoDir, {
+    url,
+    normalized: url.toLowerCase(),
+    lastFetched: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  let tempClonePath = join7(
+    repoDir,
+    `.temp-clone-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`
+  );
+  logger.debug("Cloning repository to cache", { url, ref, subdir });
+  let refDisplay = ref ? `#${ref}` : "", spinner = new GitSpinner(`Cloning repository from ${url}${refDisplay}`);
+  spinner.start();
+  try {
+    ref && isSha(ref) ? (await runGit(["clone", "--depth", "1", url, tempClonePath]), spinner.update(`Fetching commit ${ref}`), await runGit(["fetch", "--depth", "1", "origin", ref], tempClonePath), spinner.update(`Checking out commit ${ref}`), await runGit(["checkout", ref], tempClonePath)) : ref ? await runGit(["clone", "--depth", "1", "--branch", ref, url, tempClonePath]) : await runGit(["clone", "--depth", "1", url, tempClonePath]), spinner.update("Resolving commit SHA");
+    let commitSha = await getCurrentCommitSha(tempClonePath), commitDir = getGitCommitCacheDir(url, commitSha);
+    if (await isCommitCached(url, commitSha)) {
+      logger.debug("Commit already cached, using existing", { commitSha, commitDir }), spinner.stop(), await rm(tempClonePath, { recursive: !0, force: !0 }), await touchCacheEntry(commitDir);
+      let finalPath2 = subdir ? join7(commitDir, subdir) : commitDir;
+      if (subdir && !await exists(finalPath2))
+        throw new ValidationError(
+          `Subdirectory '${subdir}' does not exist in cached repository ${url}`
+        );
+      return {
+        path: finalPath2,
+        commitSha,
+        repoPath: commitDir
+      };
+    }
+    try {
+      await rename(tempClonePath, commitDir);
+    } catch (error) {
+      let code = error?.code;
+      if (code === "EEXIST" || code === "ENOTEMPTY")
+        await rm(tempClonePath, { recursive: !0, force: !0 });
+      else
+        throw error;
+    }
+    logger.debug("Moved clone to final cache location", { commitDir }), await isCommitCached(url, commitSha) && await touchCacheEntry(commitDir), await writeCommitMetadata(commitDir, {
+      url,
+      commit: commitSha,
+      ref,
+      subdir,
+      clonedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastAccessed: (/* @__PURE__ */ new Date()).toISOString()
+    }), ref && await cacheManager.cacheRefCommit(url, ref, commitSha);
+    let finalPath = subdir ? join7(commitDir, subdir) : commitDir;
+    if (subdir && !await exists(finalPath))
+      throw new ValidationError(
+        `Subdirectory '${subdir}' does not exist in cloned repository ${url}`
+      );
+    let manifestPath = join7(finalPath, FILE_PATTERNS.OPENPACKAGE_YML), hasManifest = await exists(manifestPath), pluginManifestPath = join7(finalPath, DIR_PATTERNS.CLAUDE_PLUGIN, FILE_PATTERNS.PLUGIN_JSON), hasPluginManifest = await exists(pluginManifestPath), marketplaceManifestPath = join7(finalPath, DIR_PATTERNS.CLAUDE_PLUGIN, FILE_PATTERNS.MARKETPLACE_JSON), hasMarketplaceManifest = await exists(marketplaceManifestPath);
+    if (!hasManifest && !hasPluginManifest && !hasMarketplaceManifest)
+      throw new ValidationError(
+        `Cloned repository is not an OpenPackage or Claude Code plugin (missing ${FILE_PATTERNS.OPENPACKAGE_YML}, ${DIR_PATTERNS.CLAUDE_PLUGIN}/${FILE_PATTERNS.PLUGIN_JSON}, or ${DIR_PATTERNS.CLAUDE_PLUGIN}/${FILE_PATTERNS.MARKETPLACE_JSON} at ${subdir ? `subdir '${subdir}'` : "repository root"})`
+      );
+    spinner.stop();
+    let refPart = ref ? `#${ref}` : "", subdirPart = subdir ? `&subdirectory=${subdir}` : "";
+    return logger.info(`Cloned git repository ${url}${refPart}${subdirPart} to cache [${commitSha}]`), {
+      path: finalPath,
+      commitSha,
+      repoPath: commitDir
+    };
+  } catch (error) {
+    throw spinner.stop(), await exists(tempClonePath) && await rm(tempClonePath, { recursive: !0, force: !0 }), error;
+  }
+}
+
+// ../core/src/core/install/git-package-loader.ts
+async function loadPackageFromGit(options) {
+  let cloneResult = await cloneRepoToCache({
+    url: options.url,
+    ref: options.ref,
+    subdir: options.path,
+    skipCache: options.skipCache
+  }), { path: sourcePath, repoPath, commitSha } = cloneResult;
+  if (options.resourcePath)
+    return {
+      pkg: null,
+      sourcePath,
+      repoPath,
+      commitSha,
+      isMarketplace: !1
+    };
+  let pluginDetection = await detectPluginType(sourcePath);
+  return pluginDetection.isPlugin && pluginDetection.type === "marketplace" ? {
+    pkg: null,
+    sourcePath,
+    repoPath,
+    commitSha,
+    isMarketplace: !0
+  } : {
+    pkg: await loadPackageFromPath(sourcePath, {
+      gitUrl: options.url,
+      path: options.path,
+      resourcePath: options.resourcePath,
+      repoPath
+    }),
+    sourcePath,
+    repoPath,
+    commitSha,
+    isMarketplace: !1
+  };
+}
+
+export {
+  buildPathInstallContext,
+  buildGitInstallContext,
+  buildInstallContext,
+  buildResourceInstallContexts,
+  normalizePackagePath,
+  isManifestPath,
+  createCacheManager,
+  parseDownloadIdentifier,
+  fetchRemotePackageMetadata,
+  pullPackageFromRemote,
+  loadPackageFromGit,
+  applyBaseDetection,
+  computePathScoping,
+  resolveConvenienceResources,
+  runConvenienceFilterInstall,
+  classifyInput,
+  validateResolutionFlags,
+  normalizeInstallOptions
+};
+//# sourceMappingURL=chunk-VQDTXLOX.js.map