@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-WKUYQBCG.js

@@ -1,795 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  migrateSettingsV1Document
-} from "./chunk-3HQVBIKD.js";
-import {
-  parseAgentRecipeSchema
-} from "./chunk-VAHLPXPY.js";
-import {
-  parseFleetContract
-} from "./chunk-3WBALRQH.js";
-import {
-  parseFrontmatter
-} from "./chunk-CXQ37WJH.js";
-import {
-  extensionBaseDir,
-  extensionContentDigest,
-  installExtension,
-  listInstalledExtensions,
-  loadManifestFromRoot
-} from "./chunk-DZK63TZJ.js";
-import {
-  assertAgentSpecPolicy,
-  normalizeAgentSpec
-} from "./chunk-OQM5IVJY.js";
-import {
-  readSettings,
-  settingsPath,
-  updateSettings,
-  validateSettings
-} from "./chunk-WNGF5AJX.js";
-import {
-  readClioVersion
-} from "./chunk-E3LEPLQ2.js";
-import {
-  DEFAULT_SETTINGS
-} from "./chunk-3BJGMT2D.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  safeResourceBackupPath,
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
-import {
-  clioConfigDir,
-  resolveClioDirs
-} from "./chunk-CTTI7G3T.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/share/archive.ts
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { createHash } from "node:crypto";
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  realpathSync,
-  rmSync,
-  statSync
-} from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-var PROJECT_CONTEXT_FILES = ["CLIO-CODER.md", "AGENTS.md", "CODEX.md", "GEMINI.md", "CLAUDE.md"];
-var SETTINGS_FRAGMENT_PATH = "settings.fragment.yaml";
-function sha256(buffer) {
-  return createHash("sha256").update(buffer).digest("hex");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isErrorWithCode(value) {
-  return value instanceof Error && "code" in value;
-}
-function stableJson(value) {
-  if (value === null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
-  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
-}
-function readDirRecursive(root) {
-  if (!existsSync(root)) return [];
-  const out = [];
-  const walk = (dir) => {
-    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      if (entry.name === ".DS_Store") continue;
-      const fullPath = path.join(dir, entry.name);
-      const relativePath = path.relative(root, fullPath).split(path.sep).join("/");
-      const stat = statSync(fullPath);
-      if (entry.isDirectory()) {
-        walk(fullPath);
-        continue;
-      }
-      if (entry.isFile()) out.push({ fullPath, relativePath, stat });
-    }
-  };
-  try {
-    if (statSync(root).isDirectory()) walk(root);
-  } catch {
-    return [];
-  }
-  return out;
-}
-function addBufferFile(files, input) {
-  files.push({
-    type: input.type,
-    scope: input.scope,
-    archivePath: input.archivePath.split(path.sep).join("/"),
-    relativePath: input.relativePath.split(path.sep).join("/"),
-    sha256: sha256(input.buffer),
-    size: input.buffer.byteLength,
-    encoding: "base64",
-    data: input.buffer.toString("base64")
-  });
-}
-function addTree(files, type, scope, root, archivePrefix, filter) {
-  for (const entry of readDirRecursive(root)) {
-    if (filter && !filter(entry.relativePath)) continue;
-    const buffer = readFileSync(entry.fullPath);
-    addBufferFile(files, {
-      type,
-      scope,
-      archivePath: `${archivePrefix}/${entry.relativePath}`,
-      relativePath: entry.relativePath,
-      buffer
-    });
-  }
-}
-function settingsFragment(settings) {
-  return {
-    version: 2,
-    chat: {
-      modelPicker: { cycleSet: [...settings.chat.modelPicker.cycleSet] },
-      retry: structuredClone(settings.chat.retry)
-    },
-    fleet: { concurrency: settings.fleet.concurrency },
-    context: { compaction: structuredClone(settings.context.compaction) },
-    safety: {
-      autonomy: settings.safety.autonomy,
-      limits: { sessionCostUsd: settings.safety.limits.sessionCostUsd }
-    },
-    interface: structuredClone(settings.interface)
-  };
-}
-var SETTINGS_FRAGMENT_ROOTS = ["chat", "fleet", "context", "safety", "interface"];
-function normalizedSettingsFragment(parsed) {
-  if (!isRecord(parsed)) throw new Error("settings fragment must be a YAML object");
-  let normalized = parsed;
-  if (parsed.version === void 0 || parsed.version === 1) {
-    normalized = migrateSettingsV1Document(parsed).document;
-  } else if (parsed.version !== 2) {
-    throw new Error(`settings fragment version must be 1 or 2, got ${String(parsed.version)}`);
-  }
-  const validation = validateSettings(normalized);
-  if (validation.issues.length > 0) {
-    throw new Error(
-      `invalid settings fragment: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`
-    );
-  }
-  return normalized;
-}
-function mergeFragmentValue(current, fragment) {
-  if (!isRecord(current) || !isRecord(fragment)) return structuredClone(fragment);
-  const merged = { ...current };
-  for (const [key, value] of Object.entries(fragment)) {
-    merged[key] = mergeFragmentValue(merged[key], value);
-  }
-  return merged;
-}
-function requestedScopes(scope) {
-  if (scope === "both") return ["project", "user"];
-  return [scope ?? "project"];
-}
-function defaultedIncludes(options) {
-  const hasExplicitInclude = options.includeContext !== void 0 || options.includePrompts !== void 0 || options.includeSkills !== void 0 || options.includeAgents !== void 0 || options.includeFleets !== void 0 || options.includeSettings !== void 0 || options.includeExtensions !== void 0;
-  return {
-    includeContext: hasExplicitInclude ? options.includeContext === true : true,
-    includePrompts: hasExplicitInclude ? options.includePrompts === true : true,
-    includeSkills: hasExplicitInclude ? options.includeSkills === true : true,
-    includeAgents: hasExplicitInclude ? options.includeAgents === true : true,
-    includeFleets: hasExplicitInclude ? options.includeFleets === true : true,
-    includeSettings: hasExplicitInclude ? options.includeSettings === true : true,
-    includeExtensions: hasExplicitInclude ? options.includeExtensions === true : true
-  };
-}
-function createShareArchive(options = {}) {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  const files = [];
-  const includes = defaultedIncludes(options);
-  const scopes = requestedScopes(options.scope);
-  if (includes.includeContext && scopes.includes("project")) {
-    for (const name of PROJECT_CONTEXT_FILES) {
-      const full = path.join(cwd, name);
-      try {
-        if (!statSync(full).isFile()) continue;
-        addBufferFile(files, {
-          type: "project-context",
-          scope: "project",
-          archivePath: `project/${name}`,
-          relativePath: name,
-          buffer: readFileSync(full)
-        });
-      } catch {
-      }
-    }
-  }
-  if (includes.includePrompts) {
-    for (const scope of scopes) {
-      const root = scope === "user" ? path.join(clioConfigDir(), "prompts") : path.join(cwd, ".clio-coder", "prompts");
-      addTree(files, "prompt", scope, root, `${scope}/prompts`);
-    }
-  }
-  if (includes.includeSkills) {
-    for (const scope of scopes) {
-      const root = scope === "user" ? path.join(clioConfigDir(), "skills") : path.join(cwd, ".clio-coder", "skills");
-      addTree(files, "skill", scope, root, `${scope}/skills`);
-    }
-  }
-  if (includes.includeAgents) {
-    for (const scope of scopes) {
-      const root = scope === "user" ? path.join(clioConfigDir(), "agents") : path.join(cwd, ".clio-coder", "agents");
-      addTree(files, "agent", scope, root, `${scope}/agents`);
-    }
-  }
-  if (includes.includeFleets) {
-    for (const scope of scopes) {
-      const root = scope === "user" ? path.join(clioConfigDir(), "fleets") : path.join(cwd, ".clio-coder", "fleets");
-      addTree(files, "fleet", scope, root, `${scope}/fleets`);
-    }
-  }
-  if (includes.includeExtensions) {
-    for (const scope of scopes) {
-      const root = scope === "user" ? path.join(clioConfigDir(), "extensions") : path.join(cwd, ".clio-coder", "extensions");
-      addTree(
-        files,
-        "extension",
-        scope,
-        root,
-        `${scope}/extensions`,
-        (relativePath) => !relativePath.split("/")[0]?.startsWith(".") && path.basename(relativePath) !== "state.json"
-      );
-    }
-  }
-  if (includes.includeSettings) {
-    const buffer = Buffer.from((0, import_yaml.stringify)(settingsFragment(readSettings())), "utf8");
-    addBufferFile(files, {
-      type: "settings",
-      scope: "user",
-      archivePath: SETTINGS_FRAGMENT_PATH,
-      relativePath: SETTINGS_FRAGMENT_PATH,
-      buffer
-    });
-  }
-  const manifestFiles = files.map(({ data: _data, encoding: _encoding, ...entry }) => entry);
-  return {
-    kind: "clio-coder-share-archive",
-    formatVersion: 1,
-    manifest: {
-      format: "clio-coder.share.v1",
-      clioCoderVersion: readClioVersion(),
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      files: manifestFiles
-    },
-    files: files.sort((a, b) => a.archivePath.localeCompare(b.archivePath))
-  };
-}
-function writeShareArchive(outPath, options = {}) {
-  const archive = createShareArchive(options);
-  safeResourceWrite(path.resolve(outPath), `${stableJson(archive)}
-`, { encoding: "utf8" });
-  return archive;
-}
-function decodeArchiveFile(entry) {
-  return Buffer.from(entry.data, entry.encoding);
-}
-function parseArchive(raw) {
-  if (!isRecord(raw) || raw.kind !== "clio-coder-share-archive" && raw.kind !== "clio-share-archive" || raw.formatVersion !== 1 || !isRecord(raw.manifest)) {
-    throw new Error("not a Clio share archive v1");
-  }
-  if (raw.manifest.format !== "clio-coder.share.v1" && raw.manifest.format !== "clio.share.v1" || !Array.isArray(raw.files)) {
-    throw new Error("share archive manifest is malformed");
-  }
-  const clioCoderVersion = raw.manifest.clioCoderVersion ?? raw.manifest.clioVersion;
-  if (typeof clioCoderVersion !== "string") throw new Error("share archive manifest is malformed");
-  const archive = {
-    kind: "clio-coder-share-archive",
-    formatVersion: 1,
-    manifest: {
-      format: "clio-coder.share.v1",
-      clioCoderVersion,
-      createdAt: raw.manifest.createdAt,
-      files: raw.manifest.files
-    },
-    files: raw.files
-  };
-  const allowedTypes = /* @__PURE__ */ new Set([
-    "project-context",
-    "prompt",
-    "skill",
-    "agent",
-    "fleet",
-    "settings",
-    "extension"
-  ]);
-  for (const file of archive.files) {
-    if (!isRecord(file) || !allowedTypes.has(file.type) || typeof file.archivePath !== "string" || typeof file.relativePath !== "string" || typeof file.sha256 !== "string" || file.encoding !== "base64" || typeof file.data !== "string") {
-      throw new Error("share archive file entry is malformed");
-    }
-    const actual = sha256(decodeArchiveFile(file));
-    if (actual !== file.sha256) throw new Error(`share archive checksum mismatch for ${file.archivePath}`);
-  }
-  return archive;
-}
-function readShareArchive(filePath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync(filePath, "utf8"));
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`share archive could not be read: ${reason}`);
-  }
-  return parseArchive(parsed);
-}
-function configDirPath() {
-  return path.resolve(resolveClioDirs().config);
-}
-function settingsFilePath() {
-  return path.join(configDirPath(), "settings.yaml");
-}
-function relativePathSegments(relativePath) {
-  if (relativePath.length === 0 || relativePath.includes("\0")) return null;
-  if (path.isAbsolute(relativePath) || path.win32.isAbsolute(relativePath)) return null;
-  const segments = relativePath.replace(/\\/g, "/").split("/");
-  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) return null;
-  return segments;
-}
-function targetRootForFile(entry, options) {
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  const config = configDirPath();
-  const scope = options.scope ?? entry.scope;
-  switch (entry.type) {
-    case "project-context":
-      return { root: cwd, containmentRoot: cwd, scope: "project" };
-    case "prompt":
-      return scope === "user" ? { root: path.join(config, "prompts"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "prompts"), containmentRoot: cwd, scope };
-    case "skill":
-      return scope === "user" ? { root: path.join(config, "skills"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "skills"), containmentRoot: cwd, scope };
-    case "agent":
-      return { root: path.join(config, "agents"), containmentRoot: config, scope: "user" };
-    case "fleet":
-      return { root: path.join(config, "fleets"), containmentRoot: config, scope: "user" };
-    case "extension":
-      return scope === "user" ? { root: path.join(config, "extensions"), containmentRoot: config, scope } : { root: path.join(cwd, ".clio-coder", "extensions"), containmentRoot: cwd, scope };
-    case "settings":
-      return { root: config, containmentRoot: config, scope };
-  }
-}
-function isInsideOrEqual(candidate, root) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
-}
-function lstatExists(candidate) {
-  try {
-    lstatSync(candidate);
-    return true;
-  } catch (err) {
-    if (isErrorWithCode(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) return false;
-    throw err;
-  }
-}
-function nearestExistingPath(candidate) {
-  let current = path.resolve(candidate);
-  while (!lstatExists(current)) {
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-  return current;
-}
-function pathDiagnostic(entry) {
-  return `${entry.archivePath} -> ${entry.relativePath}`;
-}
-function validateRealPathContainment(entry, target, containmentRoot) {
-  const rootAnchor = nearestExistingPath(containmentRoot);
-  const targetAnchor = nearestExistingPath(lstatExists(target) ? target : path.dirname(target));
-  if (!rootAnchor || !targetAnchor) {
-    return {
-      type: "error",
-      message: `share archive target could not be resolved safely: ${pathDiagnostic(entry)}`,
-      path: entry.relativePath
-    };
-  }
-  let realRoot;
-  let realTarget;
-  try {
-    realRoot = realpathSync(rootAnchor);
-    realTarget = realpathSync(targetAnchor);
-  } catch {
-    return {
-      type: "error",
-      message: `share archive target could not be resolved safely: ${pathDiagnostic(entry)}`,
-      path: entry.relativePath
-    };
-  }
-  if (!isInsideOrEqual(realTarget, realRoot)) {
-    return {
-      type: "error",
-      message: `share archive target escapes import root: ${pathDiagnostic(entry)}`,
-      path: entry.relativePath
-    };
-  }
-  return null;
-}
-function resolveImportTarget(entry, options) {
-  const segments = relativePathSegments(entry.relativePath);
-  if (!segments) {
-    return {
-      type: "error",
-      message: `share archive relativePath is not safe: ${pathDiagnostic(entry)}`,
-      path: entry.relativePath
-    };
-  }
-  const targetRoot = targetRootForFile(entry, options);
-  const target = entry.type === "settings" ? settingsFilePath() : path.resolve(targetRoot.root, ...segments);
-  if (!isInsideOrEqual(target, targetRoot.root)) {
-    return {
-      type: "error",
-      message: `share archive target escapes import root: ${pathDiagnostic(entry)}`,
-      path: entry.relativePath
-    };
-  }
-  const realPathDiagnostic = validateRealPathContainment(entry, target, targetRoot.containmentRoot);
-  if (realPathDiagnostic) return realPathDiagnostic;
-  return { entry, target, scope: targetRoot.scope, buffer: decodeArchiveFile(entry) };
-}
-function preflightImportTargets(archive, options) {
-  const targets = [];
-  const diagnostics = [];
-  for (const entry of archive.files) {
-    const resolved = resolveImportTarget(entry, options);
-    if ("type" in resolved) {
-      diagnostics.push(resolved);
-      continue;
-    }
-    targets.push(resolved);
-  }
-  if (diagnostics.length > 0) return { targets: [], diagnostics };
-  return { targets, diagnostics };
-}
-function withStagedExtensionPackage(input, fn) {
-  const stagingParent = mkdtempSync(path.join(tmpdir(), "clio-share-extension-"));
-  const root = path.join(stagingParent, input.id);
-  try {
-    mkdirSync(root, { recursive: true });
-    for (const file of input.files) safeResourceWrite(path.join(root, file.relativePath), file.buffer);
-    return fn(root);
-  } finally {
-    rmSync(stagingParent, { recursive: true, force: true });
-  }
-}
-function prepareExtensionPackages(targets, options) {
-  const diagnostics = [];
-  const grouped = /* @__PURE__ */ new Map();
-  for (const target of targets) {
-    if (target.entry.type !== "extension") continue;
-    const segments = relativePathSegments(target.entry.relativePath);
-    const id = segments?.[0];
-    const packagePath = segments?.slice(1).join("/");
-    if (!id || !packagePath) {
-      diagnostics.push({
-        type: "error",
-        message: `extension archive path must be <id>/<package-path>: ${pathDiagnostic(target.entry)}`,
-        path: target.entry.relativePath
-      });
-      continue;
-    }
-    const scope = target.scope;
-    const key = `${scope}\0${id}`;
-    const group = grouped.get(key) ?? { id, scope, files: [] };
-    if (group.files.some((file) => file.relativePath === packagePath)) {
-      diagnostics.push({ type: "error", message: `duplicate extension archive path ${target.entry.relativePath}` });
-      continue;
-    }
-    group.files.push({ relativePath: packagePath, buffer: target.buffer });
-    grouped.set(key, group);
-  }
-  const packages = [];
-  for (const group of [...grouped.values()].sort((a, b) => `${a.scope}/${a.id}`.localeCompare(`${b.scope}/${b.id}`))) {
-    try {
-      const contentDigest = withStagedExtensionPackage(group, (root) => {
-        const candidate = loadManifestFromRoot(root);
-        if (!candidate.valid || !candidate.manifest) {
-          throw new Error(candidate.diagnostics.map((diagnostic) => diagnostic.message).join("; ") || "manifest is invalid");
-        }
-        if (candidate.manifest.id !== group.id) {
-          throw new Error(`manifest id ${candidate.manifest.id} does not match archive package ${group.id}`);
-        }
-        return extensionContentDigest(root);
-      });
-      const cwd = path.resolve(options.cwd ?? process.cwd());
-      const targetRoot = path.join(extensionBaseDir(group.scope, cwd), group.id);
-      const existing = listInstalledExtensions(cwd, { scope: group.scope, all: true }).find(
-        (extension) => extension.id === group.id && extension.rootPath === targetRoot
-      );
-      const alreadyVerified = existing?.valid === true && existing.provenance?.contentDigest === contentDigest && existing.observedContentDigest === contentDigest;
-      if (existsSync(targetRoot) && !alreadyVerified && !options.force) {
-        diagnostics.push({
-          type: "conflict",
-          message: `extension ${group.id} is not already installed with the archive's verified digest; re-run with --force to use the canonical installer`,
-          path: targetRoot
-        });
-      }
-      packages.push({ ...group, contentDigest, install: !alreadyVerified });
-    } catch (error) {
-      diagnostics.push({
-        type: "error",
-        message: `extension ${group.id} in share archive is invalid: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  return { packages, diagnostics };
-}
-function versionDiagnostics(archive) {
-  const current = readClioVersion();
-  const [curMajor, curMinor] = current.split(".");
-  const [arcMajor, arcMinor] = archive.manifest.clioCoderVersion.split(".");
-  if (curMajor !== arcMajor || curMinor !== arcMinor) {
-    return [
-      {
-        type: "warning",
-        message: `archive was created by Clio ${archive.manifest.clioCoderVersion}; current Clio is ${current}`
-      }
-    ];
-  }
-  return [];
-}
-function settingsPlan(buffer, options) {
-  let parsed;
-  try {
-    parsed = normalizedSettingsFragment((0, import_yaml.parse)(buffer.toString("utf8")));
-  } catch (error) {
-    return [{ type: "error", message: error instanceof Error ? error.message : String(error) }];
-  }
-  const settingsTarget = settingsFilePath();
-  const current = settingsFragment(existsSync(settingsTarget) ? readSettings() : DEFAULT_SETTINGS);
-  const diagnostics = [];
-  for (const [key, value] of Object.entries(parsed).filter(
-    ([key2]) => SETTINGS_FRAGMENT_ROOTS.includes(key2)
-  )) {
-    if (key in current && JSON.stringify(current[key]) !== JSON.stringify(value)) {
-      diagnostics.push({
-        type: "conflict",
-        message: `settings fragment changes ${key}`,
-        path: settingsTarget
-      });
-    }
-  }
-  return options.force ? diagnostics.filter((diag) => diag.type !== "conflict") : diagnostics;
-}
-function prepareShareImport(filePath, options = {}) {
-  let archive;
-  try {
-    archive = readShareArchive(filePath);
-  } catch (err) {
-    return {
-      archive: null,
-      actions: [],
-      diagnostics: [{ type: "error", message: err instanceof Error ? err.message : String(err), path: filePath }],
-      targets: [],
-      extensionPackages: []
-    };
-  }
-  const diagnostics = [...versionDiagnostics(archive)];
-  const actions = [];
-  const preflight = preflightImportTargets(archive, options);
-  if (preflight.diagnostics.length > 0) {
-    return {
-      archive,
-      actions: [],
-      diagnostics: [...diagnostics, ...preflight.diagnostics],
-      targets: [],
-      extensionPackages: []
-    };
-  }
-  for (const targetInfo of preflight.targets) {
-    const { entry, target, scope, buffer } = targetInfo;
-    if (entry.type === "fleet") {
-      try {
-        parseFleetContract(buffer.toString("utf8"), target);
-      } catch (error) {
-        diagnostics.push({ type: "error", message: error instanceof Error ? error.message : String(error), path: target });
-        continue;
-      }
-    }
-    if (entry.type === "agent") {
-      try {
-        const parsed = parseFrontmatter(buffer.toString("utf8"), target);
-        const id = path.basename(target, ".md");
-        assertAgentSpecPolicy(
-          normalizeAgentSpec(parseAgentRecipeSchema({ id, source: "user", filepath: target, ...parsed }))
-        );
-      } catch (error) {
-        diagnostics.push({ type: "error", message: error instanceof Error ? error.message : String(error), path: target });
-        continue;
-      }
-    }
-    if (entry.type === "settings") {
-      diagnostics.push(...settingsPlan(buffer, options));
-      actions.push({ action: "settings", type: entry.type, scope, path: target });
-      continue;
-    }
-    if (existsSync(target)) {
-      const same = sha256(readFileSync(target)) === entry.sha256;
-      if (same) {
-        actions.push({ action: "skip", type: entry.type, scope, path: target });
-      } else if (options.force) {
-        actions.push({ action: "overwrite", type: entry.type, scope, path: target });
-      } else {
-        diagnostics.push({ type: "conflict", message: `destination already exists with different content`, path: target });
-        actions.push({ action: "skip", type: entry.type, scope, path: target });
-      }
-      continue;
-    }
-    actions.push({ action: "write", type: entry.type, scope, path: target });
-  }
-  const extensions = prepareExtensionPackages(preflight.targets, options);
-  diagnostics.push(...extensions.diagnostics);
-  return { archive, actions, diagnostics, targets: preflight.targets, extensionPackages: extensions.packages };
-}
-function publicImportPlan(prepared, recovery) {
-  return {
-    archive: prepared.archive,
-    actions: prepared.actions,
-    diagnostics: prepared.diagnostics,
-    ...recovery ? { recovery } : {}
-  };
-}
-function planShareImport(filePath, options = {}) {
-  return publicImportPlan(prepareShareImport(filePath, options));
-}
-function mergeSettingsFragment(buffer) {
-  const parsed = normalizedSettingsFragment((0, import_yaml.parse)(buffer.toString("utf8")));
-  updateSettings((settings) => {
-    const next = settings;
-    for (const key of SETTINGS_FRAGMENT_ROOTS) {
-      if (key in parsed) next[key] = mergeFragmentValue(next[key], parsed[key]);
-    }
-  });
-  return settingsPath();
-}
-function importShareArchive(filePath, options = {}) {
-  const prepared = prepareShareImport(filePath, options);
-  const plan = publicImportPlan(prepared);
-  if (!prepared.archive || options.dryRun) return plan;
-  if (prepared.diagnostics.some((diag) => diag.type === "error" || diag.type === "conflict")) return plan;
-  const written = [];
-  const backups = [];
-  const rememberWrite = (result) => {
-    if (!written.includes(result.path)) written.push(result.path);
-    if (result.backupPath && !backups.includes(result.backupPath)) backups.push(result.backupPath);
-  };
-  let failed;
-  try {
-    for (const extensionPackage of prepared.extensionPackages) {
-      if (!extensionPackage.install) continue;
-      const cwd = path.resolve(options.cwd ?? process.cwd());
-      failed = path.join(extensionBaseDir(extensionPackage.scope, cwd), extensionPackage.id);
-      const result = withStagedExtensionPackage(
-        extensionPackage,
-        (root) => installExtension(root, {
-          cwd,
-          scope: extensionPackage.scope,
-          ...options.force !== void 0 ? { force: options.force } : {}
-        })
-      );
-      for (const backup of [result.recovery?.stateBackup, result.recovery?.packageBackup]) {
-        if (backup && !backups.includes(backup)) backups.push(backup);
-      }
-      const errors = result.diagnostics.filter((diagnostic) => diagnostic.type === "error");
-      if (!result.extension || errors.length > 0) {
-        throw new Error(errors.map((diagnostic) => diagnostic.message).join("; ") || "canonical install failed");
-      }
-      if (result.extension.provenance?.contentDigest !== extensionPackage.contentDigest) {
-        throw new Error(`canonical install digest mismatch for extension ${extensionPackage.id}`);
-      }
-      for (const diagnostic of result.diagnostics) {
-        prepared.diagnostics.push({
-          type: "warning",
-          message: diagnostic.message,
-          ...diagnostic.path ? { path: diagnostic.path } : {}
-        });
-      }
-      if (!written.includes(result.extension.rootPath)) written.push(result.extension.rootPath);
-      failed = void 0;
-    }
-    for (let index = 0; index < prepared.targets.length; index += 1) {
-      const targetInfo = prepared.targets[index];
-      const action = prepared.actions[index];
-      if (!targetInfo || !action || action.action === "skip" || targetInfo.entry.type === "extension") continue;
-      failed = targetInfo.target;
-      if (targetInfo.entry.type === "settings") {
-        const path2 = mergeSettingsFragment(targetInfo.buffer);
-        if (!written.includes(path2)) written.push(path2);
-        failed = void 0;
-        continue;
-      }
-      rememberWrite(
-        safeResourceWrite(targetInfo.target, targetInfo.buffer, {
-          backup: action.action === "overwrite"
-        })
-      );
-      failed = void 0;
-    }
-    return publicImportPlan(prepared, backups.length > 0 ? { written, backups } : void 0);
-  } catch (err) {
-    if (failed) {
-      const expectedBackup = safeResourceBackupPath(failed);
-      if (existsSync(expectedBackup) && !backups.includes(expectedBackup)) backups.push(expectedBackup);
-    }
-    const reason = err instanceof Error ? err.message : String(err);
-    const recovery = {
-      written,
-      backups,
-      ...failed ? { failed } : {}
-    };
-    return publicImportPlan(
-      {
-        ...prepared,
-        diagnostics: [
-          ...prepared.diagnostics,
-          {
-            type: "error",
-            message: `share import failed${failed ? ` while importing ${failed}` : ""}: ${reason}`,
-            ...failed ? { path: failed } : {}
-          }
-        ]
-      },
-      recovery
-    );
-  }
-}
-
-// src/domains/share/index.ts
-init_esm_shims();
-
-// src/domains/share/extension.ts
-init_esm_shims();
-function createShareBundle(_context) {
-  const extension = {
-    start() {
-      return void 0;
-    }
-  };
-  const contract = {
-    createArchive(options) {
-      return createShareArchive(options);
-    },
-    writeArchive(outPath, options) {
-      return writeShareArchive(outPath, options);
-    },
-    planImport(filePath, options) {
-      return planShareImport(filePath, options);
-    },
-    importArchive(filePath, options) {
-      return importShareArchive(filePath, options);
-    }
-  };
-  return { extension, contract };
-}
-
-// src/domains/share/manifest.ts
-init_esm_shims();
-var ShareManifest = {
-  name: "share",
-  dependsOn: ["config", "extensions", "resources"]
-};
-
-// src/domains/share/index.ts
-var ShareDomainModule = {
-  manifest: ShareManifest,
-  createExtension: createShareBundle
-};
-
-export {
-  writeShareArchive,
-  planShareImport,
-  importShareArchive,
-  ShareDomainModule
-};
-//# sourceMappingURL=chunk-WKUYQBCG.js.map