opendevbrowser 0.0.21 → 0.0.23

package/dist/chunk-QVWOPIZJ.js

@@ -0,0 +1,612 @@
+import {
+  getBundledSkillsDir,
+  listBundledSkillDirectories
+} from "./chunk-3ILXPKSJ.js";
+
+// src/cli/installers/skills.ts
+import * as crypto from "crypto";
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/cli/utils/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parse as parseJsonc, modify, applyEdits } from "jsonc-parser";
+var PLUGIN_NAME = "opendevbrowser";
+var SCHEMA_URL = "https://opencode.ai/config.json";
+function getGlobalConfigPath() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), ".config", "opencode");
+  return path.join(configDir, "opencode.json");
+}
+function getLocalConfigPath() {
+  return path.join(process.cwd(), "opencode.json");
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function readConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return { content: "", config: {} };
+  }
+  const content = fs.readFileSync(configPath, "utf-8");
+  const errors = [];
+  const parsed = parseJsonc(content, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    const firstError = errors[0];
+    throw new Error(`Invalid JSONC at ${configPath}: parse error at offset ${firstError?.offset ?? 0}`);
+  }
+  return { content, config: parsed ?? {} };
+}
+function hasPlugin(config, pluginName = PLUGIN_NAME) {
+  return config.plugin?.includes(pluginName) ?? false;
+}
+function createConfigWithPlugin(pluginName = PLUGIN_NAME) {
+  return {
+    $schema: SCHEMA_URL,
+    plugin: [pluginName]
+  };
+}
+function updateConfigContent(content, pluginName = PLUGIN_NAME) {
+  if (!content.trim()) {
+    return JSON.stringify(createConfigWithPlugin(pluginName), null, 2) + "\n";
+  }
+  const parsed = parseJsonc(content, [], { allowTrailingComma: true }) ?? {};
+  if (parsed.plugin?.includes(pluginName)) {
+    return content;
+  }
+  let result = content;
+  if (!parsed.$schema) {
+    const edits2 = modify(result, ["$schema"], SCHEMA_URL, { formattingOptions: { tabSize: 2, insertSpaces: true } });
+    result = applyEdits(result, edits2);
+  }
+  const newPlugins = parsed.plugin ? [...parsed.plugin, pluginName] : [pluginName];
+  const edits = modify(result, ["plugin"], newPlugins, { formattingOptions: { tabSize: 2, insertSpaces: true } });
+  result = applyEdits(result, edits);
+  return result;
+}
+function removePluginFromContent(content, pluginName = PLUGIN_NAME) {
+  if (!content.trim()) {
+    return content;
+  }
+  const parsed = parseJsonc(content, [], { allowTrailingComma: true }) ?? {};
+  if (!parsed.plugin?.includes(pluginName)) {
+    return content;
+  }
+  const newPlugins = parsed.plugin.filter((p) => p !== pluginName);
+  const edits = modify(content, ["plugin"], newPlugins.length > 0 ? newPlugins : void 0, {
+    formattingOptions: { tabSize: 2, insertSpaces: true }
+  });
+  return applyEdits(content, edits);
+}
+
+// src/cli/utils/skills.ts
+import * as path2 from "path";
+import * as os2 from "os";
+var SKILL_DIR_NAME = "skill";
+var SKILLS_DIR_NAME = "skills";
+function getGlobalSkillDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR || path2.join(os2.homedir(), ".config", "opencode");
+  return path2.join(configDir, SKILL_DIR_NAME);
+}
+function getLocalSkillDir() {
+  return path2.join(process.cwd(), ".opencode", SKILL_DIR_NAME);
+}
+function getCodexHomeDir() {
+  return process.env.CODEX_HOME || path2.join(os2.homedir(), ".codex");
+}
+function getClaudeCodeHomeDir() {
+  return process.env.CLAUDECODE_HOME || path2.join(os2.homedir(), ".claude");
+}
+function getAmpHomeDir() {
+  return process.env.AMP_CLI_HOME || path2.join(os2.homedir(), ".amp");
+}
+function dedupeTargets(targets) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const key = path2.resolve(target.dir);
+    const existing = deduped.get(key);
+    if (existing) {
+      if (!existing.agents.includes(target.agent)) {
+        existing.agents.push(target.agent);
+      }
+      continue;
+    }
+    deduped.set(key, { agents: [target.agent], dir: target.dir });
+  }
+  return Array.from(deduped.values());
+}
+function getGlobalSkillTargets() {
+  const claudeSkillsDir = path2.join(getClaudeCodeHomeDir(), SKILLS_DIR_NAME);
+  const ampSkillsDir = path2.join(getAmpHomeDir(), SKILLS_DIR_NAME);
+  return dedupeTargets([
+    { agent: "opencode", dir: getGlobalSkillDir() },
+    { agent: "codex", dir: path2.join(getCodexHomeDir(), SKILLS_DIR_NAME) },
+    { agent: "claudecode", dir: claudeSkillsDir },
+    { agent: "ampcli", dir: ampSkillsDir }
+  ]);
+}
+function getLocalSkillTargets() {
+  const localClaudeSkillsDir = path2.join(process.cwd(), ".claude", SKILLS_DIR_NAME);
+  const localAmpSkillsDir = path2.join(process.cwd(), ".amp", SKILLS_DIR_NAME);
+  return dedupeTargets([
+    { agent: "opencode", dir: getLocalSkillDir() },
+    { agent: "codex", dir: path2.join(process.cwd(), ".codex", SKILLS_DIR_NAME) },
+    { agent: "claudecode", dir: localClaudeSkillsDir },
+    { agent: "ampcli", dir: localAmpSkillsDir }
+  ]);
+}
+
+// src/cli/installers/skills.ts
+var MANAGED_SKILLS_MARKER = ".opendevbrowser-managed-skills.json";
+var MANAGED_SKILL_SENTINEL = ".opendevbrowser-managed-skill.json";
+var MANAGED_SKILL_OWNER = "opendevbrowser";
+var MANAGED_PACK_PREFIX = "opendevbrowser-";
+function getTargets(mode) {
+  return mode === "global" ? getGlobalSkillTargets() : getLocalSkillTargets();
+}
+function getCanonicalBundledSkillNames() {
+  return listBundledSkillDirectories().map((entry) => entry.name);
+}
+function getManagedSkillsMarkerPath(targetDir) {
+  return path3.join(targetDir, MANAGED_SKILLS_MARKER);
+}
+function getManagedSkillSentinelPath(targetPath) {
+  return path3.join(targetPath, MANAGED_SKILL_SENTINEL);
+}
+function snapshotManagedSkillsMarker(targetDir) {
+  const markerPath = getManagedSkillsMarkerPath(targetDir);
+  return fs2.existsSync(markerPath) ? fs2.readFileSync(markerPath, "utf8") : null;
+}
+function restoreManagedSkillsMarker(targetDir, previousMarker) {
+  if (previousMarker === null) {
+    removeManagedSkillsMarker(targetDir);
+    return;
+  }
+  fs2.writeFileSync(getManagedSkillsMarkerPath(targetDir), previousMarker, "utf8");
+}
+function hasManagedSkillsMarker(targetDir) {
+  return fs2.existsSync(getManagedSkillsMarkerPath(targetDir));
+}
+function isSafePathSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && path3.basename(value) === value;
+}
+function isManagedPackName(value) {
+  return isSafePathSegment(value) && value.startsWith(MANAGED_PACK_PREFIX);
+}
+function readManagedSkillsMarker(targetDir) {
+  if (!hasManagedSkillsMarker(targetDir)) {
+    return null;
+  }
+  try {
+    const raw = fs2.readFileSync(getManagedSkillsMarkerPath(targetDir), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.managedPacks) ? {
+      managedPacks: parsed.managedPacks.filter(
+        (value) => typeof value === "string" && isManagedPackName(value)
+      ),
+      managesAllCanonicalPacks: parsed.managesAllCanonicalPacks !== false
+    } : null;
+  } catch {
+    return null;
+  }
+}
+function writeManagedSkillsMarker(targetDir, packNames, managesAllCanonicalPacks) {
+  const marker = {
+    managedPacks: Array.from(new Set(packNames)),
+    managesAllCanonicalPacks
+  };
+  fs2.writeFileSync(
+    getManagedSkillsMarkerPath(targetDir),
+    `${JSON.stringify(marker, null, 2)}
+`,
+    "utf8"
+  );
+}
+function removeManagedSkillsMarker(targetDir) {
+  fs2.rmSync(getManagedSkillsMarkerPath(targetDir), { force: true });
+}
+function writeManagedSkillSentinel(targetPath, packName, fingerprint) {
+  const sentinel = {
+    managedBy: MANAGED_SKILL_OWNER,
+    packName,
+    fingerprint
+  };
+  fs2.writeFileSync(
+    getManagedSkillSentinelPath(targetPath),
+    `${JSON.stringify(sentinel, null, 2)}
+`,
+    "utf8"
+  );
+}
+function readManagedSkillFingerprint(targetPath) {
+  const sentinelPath = getManagedSkillSentinelPath(targetPath);
+  if (!fs2.existsSync(sentinelPath)) {
+    return null;
+  }
+  try {
+    const raw = fs2.readFileSync(sentinelPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.managedBy === MANAGED_SKILL_OWNER && parsed.packName === path3.basename(targetPath) && typeof parsed.fingerprint === "string" ? parsed.fingerprint : null;
+  } catch {
+    return null;
+  }
+}
+function getSentinelManagedPackNames(targetDir, packNames) {
+  const canonicalPackNames = new Set(packNames);
+  const candidatePackNames = new Set(packNames);
+  if (fs2.existsSync(targetDir) && isDirectoryPath(targetDir)) {
+    for (const entry of fs2.readdirSync(targetDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && isManagedPackName(entry.name)) {
+        candidatePackNames.add(entry.name);
+      }
+    }
+  }
+  return Array.from(candidatePackNames).filter((packName) => {
+    const targetPath = path3.join(targetDir, packName);
+    if (!fs2.existsSync(targetPath) || readManagedSkillFingerprint(targetPath) === null) {
+      return false;
+    }
+    return canonicalPackNames.has(packName) || shouldRemoveRetiredManagedPack(targetPath);
+  });
+}
+function hasManagedCanonicalBundledSkillInTarget(targetDir, packNames) {
+  return getSentinelManagedPackNames(targetDir, packNames).length > 0;
+}
+function removeManagedPackArtifacts(targetDir, packNames) {
+  const removed = [];
+  const missing = [];
+  for (const packName of packNames) {
+    const targetPath = path3.join(targetDir, packName);
+    if (fs2.existsSync(targetPath)) {
+      fs2.rmSync(targetPath, { recursive: true, force: true });
+      removed.push(packName);
+      continue;
+    }
+    missing.push(packName);
+  }
+  return { removed, missing };
+}
+function formatSummary(parts, totalTargets, failures) {
+  const summary = parts.length > 0 ? parts.join(", ") : "no lifecycle changes";
+  const failureSummary = failures > 0 ? `, ${failures} failed` : "";
+  return `${summary} across ${totalTargets} targets${failureSummary}`;
+}
+function hashDirectoryTree(dirPath) {
+  const hash = crypto.createHash("sha256");
+  const visit = (currentPath, relativePath) => {
+    const entries = fs2.readdirSync(currentPath, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const absolutePath = path3.join(currentPath, entry.name);
+      const entryRelativePath = relativePath ? path3.posix.join(relativePath, entry.name) : entry.name;
+      if (entry.isFile() && entry.name === MANAGED_SKILL_SENTINEL) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        hash.update(`D:${entryRelativePath}\0`);
+        visit(absolutePath, entryRelativePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        hash.update(`F:${entryRelativePath}\0`);
+        hash.update(fs2.readFileSync(absolutePath));
+        hash.update("\0");
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        hash.update(`L:${entryRelativePath}\0${fs2.readlinkSync(absolutePath)}\0`);
+      }
+    }
+  };
+  visit(dirPath, "");
+  return hash.digest("hex");
+}
+function isDirectoryPath(targetPath) {
+  return fs2.lstatSync(targetPath).isDirectory();
+}
+function shouldRemoveRetiredManagedPack(targetPath) {
+  if (!fs2.existsSync(targetPath) || !isDirectoryPath(targetPath)) {
+    return false;
+  }
+  const fingerprint = readManagedSkillFingerprint(targetPath);
+  return fingerprint !== null && hashDirectoryTree(targetPath) === fingerprint;
+}
+function syncSkillDirectory(sourcePath, targetPath, sourceFingerprint) {
+  if (!fs2.existsSync(targetPath)) {
+    fs2.cpSync(sourcePath, targetPath, { recursive: true });
+    return "installed";
+  }
+  if (isDirectoryPath(targetPath)) {
+    const targetFingerprint = hashDirectoryTree(targetPath);
+    if (targetFingerprint === sourceFingerprint) {
+      return "unchanged";
+    }
+  }
+  const parentDir = path3.dirname(targetPath);
+  const targetName = path3.basename(targetPath);
+  const stagingRoot = fs2.mkdtempSync(path3.join(parentDir, `.${targetName}-sync-`));
+  const stagedPath = path3.join(stagingRoot, targetName);
+  const backupPath = path3.join(stagingRoot, `${targetName}-backup`);
+  try {
+    fs2.cpSync(sourcePath, stagedPath, { recursive: true });
+    fs2.renameSync(targetPath, backupPath);
+    try {
+      fs2.renameSync(stagedPath, targetPath);
+    } catch (error) {
+      if (fs2.existsSync(backupPath) && !fs2.existsSync(targetPath)) {
+        fs2.renameSync(backupPath, targetPath);
+      }
+      throw error;
+    }
+    fs2.rmSync(backupPath, { recursive: true, force: true });
+    return "refreshed";
+  } finally {
+    if (fs2.existsSync(stagedPath)) {
+      fs2.rmSync(stagedPath, { recursive: true, force: true });
+    }
+    if (fs2.existsSync(backupPath)) {
+      fs2.rmSync(backupPath, { recursive: true, force: true });
+    }
+    fs2.rmSync(stagingRoot, { recursive: true, force: true });
+  }
+}
+function buildSyncMessage(mode, result) {
+  return `Skills ${mode} sync: ${formatSummary(
+    [
+      result.installed.length > 0 ? `${result.installed.length} installed` : "",
+      result.refreshed.length > 0 ? `${result.refreshed.length} refreshed` : "",
+      result.unchanged.length > 0 ? `${result.unchanged.length} unchanged` : ""
+    ].filter(Boolean),
+    result.targets.length,
+    result.targets.filter((entry) => !entry.success).length
+  )}`;
+}
+function buildRemovalMessage(mode, result) {
+  return `Skills ${mode} removal: ${formatSummary(
+    [
+      result.removed.length > 0 ? `${result.removed.length} removed` : "",
+      result.missing.length > 0 ? `${result.missing.length} already absent` : ""
+    ].filter(Boolean),
+    result.targets.length,
+    result.targets.filter((entry) => !entry.success).length
+  )}`;
+}
+function resolveManagedPackScope(target, marker, packNames) {
+  const requestedAllCanonicalPacks = target.managedPackNames === void 0;
+  const managesAllCanonicalPacks = requestedAllCanonicalPacks || marker?.managesAllCanonicalPacks === true;
+  const managedPackNames = managesAllCanonicalPacks ? Array.from(/* @__PURE__ */ new Set([...marker?.managedPacks ?? [], ...packNames])) : Array.from(new Set(target.managedPackNames ?? marker?.managedPacks ?? []));
+  const activePackNames = managesAllCanonicalPacks ? [...packNames] : managedPackNames.filter((packName) => packNames.includes(packName));
+  return {
+    managedPackNames,
+    activePackNames,
+    managesAllCanonicalPacks
+  };
+}
+function createNoOpSkillRemovalResult(mode) {
+  const result = {
+    success: true,
+    message: "",
+    mode,
+    targets: [],
+    removed: [],
+    missing: []
+  };
+  result.message = buildRemovalMessage(mode, result);
+  return result;
+}
+function getBundledSkillLifecycleTargets(mode, options) {
+  const packNames = getCanonicalBundledSkillNames();
+  return getTargets(mode).flatMap((target) => {
+    const marker = readManagedSkillsMarker(target.dir);
+    if (marker) {
+      if (marker.managesAllCanonicalPacks || !options.includeLegacyArtifacts) {
+        return marker.managesAllCanonicalPacks ? [target] : [{ ...target, managedPackNames: marker.managedPacks }];
+      }
+      const managedPackNames2 = Array.from(/* @__PURE__ */ new Set([
+        ...marker.managedPacks,
+        ...getSentinelManagedPackNames(target.dir, packNames)
+      ]));
+      return managedPackNames2.length > 0 ? [{ ...target, managedPackNames: managedPackNames2 }] : [];
+    }
+    if (!options.includeLegacyArtifacts) {
+      return [];
+    }
+    const managedPackNames = getSentinelManagedPackNames(target.dir, packNames);
+    return managedPackNames.length > 0 ? [{ ...target, managedPackNames }] : [];
+  });
+}
+function getBundledSkillTargets(mode) {
+  return getTargets(mode);
+}
+function syncBundledSkillsForTargets(mode, targets) {
+  const targetResults = [];
+  try {
+    const sourceDir = getBundledSkillsDir();
+    const packNames = getCanonicalBundledSkillNames();
+    const bundledFingerprints = /* @__PURE__ */ new Map();
+    for (const packName of packNames) {
+      const sourcePath = path3.join(sourceDir, packName);
+      if (!fs2.existsSync(sourcePath)) {
+        throw new Error(`Bundled skill directory missing: ${packName}`);
+      }
+      bundledFingerprints.set(packName, hashDirectoryTree(sourcePath));
+    }
+    for (const target of targets) {
+      const installed = [];
+      const refreshed = [];
+      const unchanged = [];
+      const previousMarker = snapshotManagedSkillsMarker(target.dir);
+      try {
+        ensureDir(target.dir);
+        const managedTarget = target;
+        const marker = readManagedSkillsMarker(target.dir);
+        const { managedPackNames, activePackNames, managesAllCanonicalPacks } = resolveManagedPackScope(
+          managedTarget,
+          marker,
+          packNames
+        );
+        const activePackNameSet = new Set(activePackNames);
+        writeManagedSkillsMarker(target.dir, managedPackNames, managesAllCanonicalPacks);
+        for (const packName of activePackNames) {
+          const sourcePath = path3.join(sourceDir, packName);
+          const targetPath = path3.join(target.dir, packName);
+          const sourceFingerprint = bundledFingerprints.get(packName);
+          if (!sourceFingerprint) {
+            throw new Error(`Bundled fingerprint missing: ${packName}`);
+          }
+          const outcome = syncSkillDirectory(sourcePath, targetPath, sourceFingerprint);
+          writeManagedSkillSentinel(targetPath, packName, sourceFingerprint);
+          if (outcome === "installed") {
+            installed.push(packName);
+          } else if (outcome === "refreshed") {
+            refreshed.push(packName);
+          } else {
+            unchanged.push(packName);
+          }
+        }
+        const retiredPackNames = managedPackNames.filter((packName) => {
+          return !activePackNameSet.has(packName) && shouldRemoveRetiredManagedPack(path3.join(target.dir, packName));
+        });
+        removeManagedPackArtifacts(target.dir, retiredPackNames);
+        if (activePackNames.length > 0 || managesAllCanonicalPacks) {
+          writeManagedSkillsMarker(target.dir, activePackNames, managesAllCanonicalPacks);
+        } else {
+          removeManagedSkillsMarker(target.dir);
+        }
+        targetResults.push({
+          agents: target.agents,
+          targetDir: target.dir,
+          installed,
+          refreshed,
+          unchanged,
+          success: true
+        });
+      } catch (error) {
+        restoreManagedSkillsMarker(target.dir, previousMarker);
+        const message = error instanceof Error ? error.message : String(error);
+        targetResults.push({
+          agents: target.agents,
+          targetDir: target.dir,
+          installed,
+          refreshed,
+          unchanged,
+          success: false,
+          error: message
+        });
+      }
+    }
+    const result = {
+      success: targetResults.every((entry) => entry.success),
+      message: "",
+      mode,
+      targets: targetResults,
+      installed: targetResults.flatMap((entry) => entry.installed),
+      refreshed: targetResults.flatMap((entry) => entry.refreshed),
+      unchanged: targetResults.flatMap((entry) => entry.unchanged)
+    };
+    result.message = buildSyncMessage(mode, result);
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const result = {
+      success: false,
+      message: "",
+      mode,
+      targets: targetResults,
+      installed: targetResults.flatMap((entry) => entry.installed),
+      refreshed: targetResults.flatMap((entry) => entry.refreshed),
+      unchanged: targetResults.flatMap((entry) => entry.unchanged)
+    };
+    result.message = `Failed to sync skills (${mode}): ${message}`;
+    return result;
+  }
+}
+function syncBundledSkills(mode) {
+  return syncBundledSkillsForTargets(mode, getTargets(mode));
+}
+function removeBundledSkillsForTargets(mode, targets) {
+  const packNames = getCanonicalBundledSkillNames();
+  const targetResults = [];
+  for (const target of targets) {
+    const removed = [];
+    const missing = [];
+    try {
+      const managedTarget = target;
+      const marker = readManagedSkillsMarker(target.dir);
+      const { managedPackNames, activePackNames } = resolveManagedPackScope(
+        managedTarget,
+        marker,
+        packNames
+      );
+      const currentRemoval = removeManagedPackArtifacts(
+        target.dir,
+        activePackNames
+      );
+      removed.push(...currentRemoval.removed);
+      missing.push(...currentRemoval.missing);
+      const retiredPackNames = managedPackNames.filter((packName) => {
+        return !packNames.includes(packName) && shouldRemoveRetiredManagedPack(path3.join(target.dir, packName));
+      });
+      const retiredRemoval = removeManagedPackArtifacts(target.dir, retiredPackNames);
+      removed.push(...retiredRemoval.removed);
+      missing.push(...retiredRemoval.missing);
+      removeManagedSkillsMarker(target.dir);
+      targetResults.push({
+        agents: target.agents,
+        targetDir: target.dir,
+        removed,
+        missing,
+        success: true
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      targetResults.push({
+        agents: target.agents,
+        targetDir: target.dir,
+        removed,
+        missing,
+        success: false,
+        error: message
+      });
+    }
+  }
+  const result = {
+    success: targetResults.every((entry) => entry.success),
+    message: "",
+    mode,
+    targets: targetResults,
+    removed: targetResults.flatMap((entry) => entry.removed),
+    missing: targetResults.flatMap((entry) => entry.missing)
+  };
+  result.message = buildRemovalMessage(mode, result);
+  return result;
+}
+function hasBundledSkillArtifacts(mode) {
+  const packNames = getCanonicalBundledSkillNames();
+  const targets = getTargets(mode);
+  return targets.some((target) => hasManagedCanonicalBundledSkillInTarget(target.dir, packNames));
+}
+function hasManagedBundledSkillInstall(mode) {
+  return getTargets(mode).some((target) => readManagedSkillsMarker(target.dir) !== null);
+}
+
+export {
+  getGlobalConfigPath,
+  getLocalConfigPath,
+  ensureDir,
+  readConfig,
+  hasPlugin,
+  updateConfigContent,
+  removePluginFromContent,
+  createNoOpSkillRemovalResult,
+  getBundledSkillLifecycleTargets,
+  getBundledSkillTargets,
+  syncBundledSkillsForTargets,
+  syncBundledSkills,
+  removeBundledSkillsForTargets,
+  hasBundledSkillArtifacts,
+  hasManagedBundledSkillInstall
+};
+//# sourceMappingURL=chunk-QVWOPIZJ.js.map