@iowarp/clio-coder 0.4.0 → 0.4.2

package/dist/{chunk-O4XIVISU.js → chunk-UH347SHR.js}

@@ -1,28 +1,39 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  migrateSettingsV1Document
+} from "./chunk-3KIPBMUA.js";
 import {
   parseAgentRecipeSchema
-} from "./chunk-Z4TXYIEG.js";
+} from "./chunk-CRFOIAX3.js";
 import {
   parseFleetContract
-} from "./chunk-CTJ4RNAA.js";
+} from "./chunk-3F7VUY77.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
+import {
+  extensionBaseDir,
+  extensionContentDigest,
+  installExtension,
+  listInstalledExtensions,
+  loadManifestFromRoot
+} from "./chunk-77QIVUZB.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-PGF63K6I.js";
 import {
   readSettings,
   settingsPath,
-  updateSettings
-} from "./chunk-VFA6GDY5.js";
+  updateSettings,
+  validateSettings
+} from "./chunk-34BHNEE3.js";
 import {
   readClioVersion
 } from "./chunk-IWHMRKLL.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-GXNLGKAB.js";
+} from "./chunk-UXCU4E3T.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -43,7 +54,18 @@ import {
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+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";
@@ -111,16 +133,45 @@ function addTree(files, type, scope, root, archivePrefix, filter) {
 }
 function settingsFragment(settings) {
   return {
-    autonomy: settings.autonomy,
-    scope: settings.scope,
-    budget: settings.budget,
-    theme: settings.theme,
-    terminal: settings.terminal,
-    keybindings: settings.keybindings,
-    compaction: settings.compaction,
-    retry: settings.retry
+    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"];
@@ -185,7 +236,14 @@ function createShareArchive(options = {}) {
   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`, (rel) => path.basename(rel) !== "state.json");
+      addTree(
+        files,
+        "extension",
+        scope,
+        root,
+        `${scope}/extensions`,
+        (relativePath) => !relativePath.split("/")[0]?.startsWith(".") && path.basename(relativePath) !== "state.json"
+      );
     }
   }
   if (includes.includeSettings) {
@@ -200,11 +258,11 @@ function createShareArchive(options = {}) {
   }
   const manifestFiles = files.map(({ data: _data, encoding: _encoding, ...entry }) => entry);
   return {
-    kind: "clio-share-archive",
+    kind: "clio-coder-share-archive",
     formatVersion: 1,
     manifest: {
-      format: "clio.share.v1",
-      clioVersion: readClioVersion(),
+      format: "clio-coder.share.v1",
+      clioCoderVersion: readClioVersion(),
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       files: manifestFiles
     },
@@ -221,13 +279,25 @@ function decodeArchiveFile(entry) {
   return Buffer.from(entry.data, entry.encoding);
 }
 function parseArchive(raw) {
-  if (!isRecord(raw) || raw.kind !== "clio-share-archive" || raw.formatVersion !== 1 || !isRecord(raw.manifest)) {
+  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.share.v1" || !Array.isArray(raw.files)) {
+  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 archive = raw;
+  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",
@@ -382,27 +452,106 @@ function preflightImportTargets(archive, options) {
   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.clioVersion.split(".");
+  const [arcMajor, arcMinor] = archive.manifest.clioCoderVersion.split(".");
   if (curMajor !== arcMajor || curMinor !== arcMinor) {
     return [
       {
         type: "warning",
-        message: `archive was created by Clio ${archive.manifest.clioVersion}; current Clio is ${current}`
+        message: `archive was created by Clio ${archive.manifest.clioCoderVersion}; current Clio is ${current}`
       }
     ];
   }
   return [];
 }
 function settingsPlan(buffer, options) {
-  const parsed = (0, import_yaml.parse)(buffer.toString("utf8"));
-  if (!isRecord(parsed)) return [{ type: "error", message: "settings fragment must be a YAML object" }];
+  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)) {
+  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",
@@ -422,14 +571,21 @@ function prepareShareImport(filePath, options = {}) {
       archive: null,
       actions: [],
       diagnostics: [{ type: "error", message: err instanceof Error ? err.message : String(err), path: filePath }],
-      targets: []
+      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: [] };
+    return {
+      archive,
+      actions: [],
+      diagnostics: [...diagnostics, ...preflight.diagnostics],
+      targets: [],
+      extensionPackages: []
+    };
   }
   for (const targetInfo of preflight.targets) {
     const { entry, target, scope, buffer } = targetInfo;
@@ -472,7 +628,9 @@ function prepareShareImport(filePath, options = {}) {
     }
     actions.push({ action: "write", type: entry.type, scope, path: target });
   }
-  return { archive, actions, diagnostics, targets: preflight.targets };
+  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 {
@@ -486,21 +644,11 @@ function planShareImport(filePath, options = {}) {
   return publicImportPlan(prepareShareImport(filePath, options));
 }
 function mergeSettingsFragment(buffer) {
-  const parsed = (0, import_yaml.parse)(buffer.toString("utf8"));
-  if (!isRecord(parsed)) throw new Error("settings fragment must be a YAML object");
+  const parsed = normalizedSettingsFragment((0, import_yaml.parse)(buffer.toString("utf8")));
   updateSettings((settings) => {
     const next = settings;
-    for (const key of [
-      "autonomy",
-      "scope",
-      "budget",
-      "theme",
-      "terminal",
-      "keybindings",
-      "compaction",
-      "retry"
-    ]) {
-      if (key in parsed) next[key] = parsed[key];
+    for (const key of SETTINGS_FRAGMENT_ROOTS) {
+      if (key in parsed) next[key] = mergeFragmentValue(next[key], parsed[key]);
     }
   });
   return settingsPath();
@@ -518,10 +666,42 @@ function importShareArchive(filePath, options = {}) {
   };
   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") continue;
+      if (!targetInfo || !action || action.action === "skip" || targetInfo.entry.type === "extension") continue;
       failed = targetInfo.target;
       if (targetInfo.entry.type === "settings") {
         const path2 = mergeSettingsFragment(targetInfo.buffer);
@@ -536,7 +716,7 @@ function importShareArchive(filePath, options = {}) {
       );
       failed = void 0;
     }
-    return plan;
+    return publicImportPlan(prepared, backups.length > 0 ? { written, backups } : void 0);
   } catch (err) {
     if (failed) {
       const expectedBackup = safeResourceBackupPath(failed);
@@ -555,7 +735,7 @@ function importShareArchive(filePath, options = {}) {
           ...prepared.diagnostics,
           {
             type: "error",
-            message: `share import failed while writing${failed ? ` ${failed}` : ""}: ${reason}`,
+            message: `share import failed${failed ? ` while importing ${failed}` : ""}: ${reason}`,
             ...failed ? { path: failed } : {}
           }
         ]
@@ -612,4 +792,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-O4XIVISU.js.map
+//# sourceMappingURL=chunk-UH347SHR.js.map

package/dist/{chunk-OQBA45DZ.js → chunk-UH632ZYL.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   compileExecutionPlan
-} from "./chunk-QBJA7R7N.js";
+} from "./chunk-DZAW46HP.js";
 import {
   deriveExecutionRole
 } from "./chunk-H7IXIC72.js";
@@ -94,4 +94,4 @@ function compileScoutTransition(input) {
 export {
   compileScoutTransition
 };
-//# sourceMappingURL=chunk-OQBA45DZ.js.map
+//# sourceMappingURL=chunk-UH632ZYL.js.map