@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-6TKOFFGE.js

@@ -1,1058 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  evaluateClioCompatibility,
-  extensionContentDigest,
-  extensionContentDigestWithCapture
-} from "./chunk-XW2UZICE.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  clioConfigDir
-} from "./chunk-CTTI7G3T.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/extensions/discovery.ts
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, readdirSync, readFileSync, realpathSync as realpathSync2, statSync } from "node:fs";
-import path2 from "node:path";
-
-// src/domains/extensions/command-schema.ts
-init_esm_shims();
-import { lstatSync, realpathSync } from "node:fs";
-import path from "node:path";
-var TOOL_KEYS = /* @__PURE__ */ new Set([
-  "name",
-  "description",
-  "runtime",
-  "entrypoint",
-  "inputSchema",
-  "timeoutMs",
-  "maxOutputBytes"
-]);
-var SCHEMA_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "description",
-  "properties",
-  "required",
-  "additionalProperties",
-  "items",
-  "enum",
-  "minimum",
-  "maximum",
-  "minLength",
-  "maxLength",
-  "minItems",
-  "maxItems"
-]);
-var TYPES = /* @__PURE__ */ new Set(["object", "array", "string", "number", "integer", "boolean", "null"]);
-function record(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function extensionToolName(id, name) {
-  return `extension_${id}__${name}`;
-}
-function validateSchema(value, depth = 0) {
-  if (depth > 12 || !record(value))
-    throw new Error("inputSchema must be a JSON schema object with at most 12 nesting levels");
-  for (const key of Object.keys(value)) {
-    if (!SCHEMA_KEYS.has(key)) throw new Error(`unsupported inputSchema keyword '${key}'`);
-  }
-  if (typeof value.type !== "string" || !TYPES.has(value.type))
-    throw new Error("inputSchema.type must be a supported JSON type");
-  if (value.description !== void 0 && typeof value.description !== "string")
-    throw new Error("inputSchema.description must be a string");
-  if (value.enum !== void 0 && (!Array.isArray(value.enum) || value.enum.length === 0 || value.enum.some((item) => item !== null && typeof item === "object"))) {
-    throw new Error("inputSchema.enum must contain JSON scalar values");
-  }
-  for (const key of ["minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"]) {
-    if (value[key] !== void 0 && (typeof value[key] !== "number" || !Number.isFinite(value[key])))
-      throw new Error(`inputSchema.${key} must be finite`);
-  }
-  if (value.type === "object") {
-    if (!record(value.properties) || value.additionalProperties !== false)
-      throw new Error("object inputSchema requires properties and additionalProperties: false");
-    for (const [key, child] of Object.entries(value.properties)) {
-      if (["__proto__", "constructor", "prototype"].includes(key)) throw new Error("unsafe inputSchema property name");
-      validateSchema(child, depth + 1);
-    }
-    if (value.required !== void 0 && (!Array.isArray(value.required) || value.required.some((key) => typeof key !== "string" || !Object.hasOwn(value.properties, key)))) {
-      throw new Error("inputSchema.required must name declared properties");
-    }
-  } else if (value.type === "array") {
-    validateSchema(value.items, depth + 1);
-  }
-}
-function parseExtensionCapabilities(value, id) {
-  if (!record(value) || Object.keys(value).some((key) => key !== "tools") || !Array.isArray(value.tools) || value.tools.length === 0 || value.tools.length > 32) {
-    throw new Error("capabilities must contain tools with between 1 and 32 command declarations");
-  }
-  if (id.includes("__")) throw new Error("v2 extension id cannot contain double underscores");
-  const names = /* @__PURE__ */ new Set();
-  const tools = value.tools.map((tool) => {
-    if (!record(tool)) throw new Error("capabilities.tools entries must be objects");
-    for (const key of Object.keys(tool)) if (!TOOL_KEYS.has(key)) throw new Error(`unknown command tool key '${key}'`);
-    if (typeof tool.name !== "string" || !/^[a-z][a-z0-9_]*$/.test(tool.name) || tool.name.includes("__"))
-      throw new Error("command tool name must use lowercase letters, digits, and single underscores");
-    const name = extensionToolName(id, tool.name);
-    if (name.length > 64 || !/^[a-zA-Z0-9_-]+$/.test(name))
-      throw new Error("qualified command tool name must use provider-safe characters and fit 64 characters");
-    if (names.has(name)) throw new Error(`duplicate command tool name '${name}'`);
-    names.add(name);
-    if (typeof tool.description !== "string" || tool.description.trim().length === 0 || tool.description.length > 2e3)
-      throw new Error("command tool description must contain 1 to 2000 characters");
-    if (tool.runtime !== "node" && tool.runtime !== "python3")
-      throw new Error("command tool runtime must be node or python3");
-    if (typeof tool.entrypoint !== "string" || tool.entrypoint.includes("\0") || tool.entrypoint.includes("\\") || path.isAbsolute(tool.entrypoint) || tool.entrypoint.split("/").some((part) => part === ".." || part === "." || part === ""))
-      throw new Error("command tool entrypoint must be a contained relative file path");
-    validateSchema(tool.inputSchema);
-    if (tool.inputSchema.type !== "object") throw new Error("command tool inputSchema root must be object");
-    for (const [key, maximum] of [
-      ["timeoutMs", 3e5],
-      ["maxOutputBytes", 1048576]
-    ]) {
-      const limit = tool[key];
-      if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > maximum))
-        throw new Error(`command tool ${key} must be between 1 and ${maximum}`);
-    }
-    return structuredClone(tool);
-  });
-  return { tools };
-}
-function resolveExtensionEntrypoint(root, entrypoint) {
-  const canonicalRoot = realpathSync(root);
-  let cursor = canonicalRoot;
-  for (const segment of entrypoint.split("/")) {
-    if (segment === ".." || segment === "." || segment.length === 0)
-      throw new Error("invalid command entrypoint segment");
-    cursor = path.join(cursor, segment);
-    if (lstatSync(cursor).isSymbolicLink()) throw new Error("command entrypoint cannot contain symbolic links");
-  }
-  const stat = lstatSync(cursor);
-  if (!stat.isFile() || stat.nlink !== 1) throw new Error("command entrypoint must be an ordinary file with one link");
-  const relative = path.relative(canonicalRoot, realpathSync(cursor));
-  if (relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
-    throw new Error("command entrypoint escapes extension root");
-  return cursor;
-}
-
-// src/domains/extensions/runtime-schema.ts
-init_esm_shims();
-import { stripVTControlCharacters } from "node:util";
-var RUNTIME_LIMITS = {
-  processes: 4,
-  messageBytes: 96 * 1024,
-  outputBytes: 64 * 1024,
-  argumentBytes: 16 * 1024,
-  startupMs: 5e3,
-  commandMs: 3e4,
-  observationMs: 2e3,
-  disposeMs: 250,
-  diagnosticsBytes: 64 * 1024
-};
-function record2(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("expected an object");
-  return value;
-}
-function keys(value, allowed) {
-  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`unknown runtime field '${key}'`);
-}
-function string(value, max) {
-  if (typeof value !== "string" || value.length === 0 || value.length > max)
-    throw new Error(`expected text of 1-${max} characters`);
-  return value;
-}
-function array(value, max) {
-  if (!Array.isArray(value) || value.length > max) throw new Error(`expected an array of at most ${max} entries`);
-  return value;
-}
-function choices(value, allowed) {
-  const entries = array(value ?? [], allowed.length).map((item) => {
-    if (!allowed.includes(item)) throw new Error(`unsupported runtime capability '${String(item)}'`);
-    return item;
-  });
-  if (new Set(entries).size !== entries.length) throw new Error("duplicate runtime capability");
-  return entries;
-}
-function parseExtensionRuntime(value) {
-  const raw = record2(value);
-  keys(raw, ["api", "entrypoint", "commands", "events", "ui"]);
-  if (raw.api !== 1) throw new Error("runtime.api must be 1");
-  const entrypoint = string(raw.entrypoint, 240);
-  if (!entrypoint.endsWith(".mjs")) throw new Error("runtime.entrypoint must be a shipped .mjs file");
-  const names = /* @__PURE__ */ new Set();
-  const commands = array(raw.commands ?? [], 32).map((value2) => {
-    const command = record2(value2);
-    keys(command, ["name", "description", "timeoutMs"]);
-    const name = string(command.name, 40);
-    if (!/^[a-z][a-z0-9_]*$/.test(name) || names.has(name))
-      throw new Error(`invalid or duplicate runtime command '${name}'`);
-    names.add(name);
-    const description = string(command.description, 240);
-    const timeoutMs = command.timeoutMs ?? RUNTIME_LIMITS.commandMs;
-    if (!Number.isInteger(timeoutMs) || Number(timeoutMs) < 100 || Number(timeoutMs) > 3e5)
-      throw new Error("runtime command timeoutMs must be 100-300000");
-    return { name, description, timeoutMs: Number(timeoutMs) };
-  });
-  return {
-    api: 1,
-    entrypoint,
-    commands,
-    events: choices(raw.events, ["session_open", "turn_end"]),
-    ui: choices(raw.ui, ["status", "panel"])
-  };
-}
-function extensionPlainText(value) {
-  return stripVTControlCharacters(value).replace(
-    /[\p{Cc}\p{Cf}]/gu,
-    (char) => char === "\n" || char === "	" ? char : ""
-  );
-}
-function text(value, max) {
-  if (value === "") return "";
-  return extensionPlainText(string(value, max));
-}
-function parseExtensionOutput(value, declaration) {
-  if (Buffer.byteLength(JSON.stringify(value) ?? "") > RUNTIME_LIMITS.outputBytes)
-    throw new Error("runtime output exceeds 64 KiB");
-  const raw = record2(value);
-  keys(raw, ["text", "status", "panel"]);
-  const output = { text: text(raw.text, 32768) };
-  if (raw.status !== void 0) {
-    if (!declaration.ui.includes("status")) throw new Error("runtime did not declare status UI");
-    if (raw.status === null) output.status = null;
-    else {
-      const status = record2(raw.status);
-      keys(status, ["text", "tone"]);
-      const parsed = { text: text(status.text, 160).replaceAll("\n", " ").replaceAll("	", " ") };
-      if (status.tone !== void 0) {
-        const [tone] = choices([status.tone], ["neutral", "positive", "warning", "error"]);
-        if (tone) parsed.tone = tone;
-      }
-      output.status = parsed;
-    }
-  }
-  if (raw.panel !== void 0) {
-    if (!declaration.ui.includes("panel")) throw new Error("runtime did not declare panel UI");
-    const panel = record2(raw.panel);
-    keys(panel, ["title", "sections"]);
-    const parsed = { title: text(panel.title, 120), sections: [] };
-    for (const value2 of array(panel.sections, 16)) {
-      const section = record2(value2);
-      if (section.kind === "text") {
-        keys(section, ["kind", "text"]);
-        parsed.sections.push({ kind: "text", text: text(section.text, 8192) });
-      } else if (section.kind === "metrics") {
-        keys(section, ["kind", "items"]);
-        parsed.sections.push({
-          kind: "metrics",
-          items: array(section.items, 32).map((value3) => {
-            const item = record2(value3);
-            keys(item, ["label", "value"]);
-            return { label: text(item.label, 120), value: text(item.value, 240) };
-          })
-        });
-      } else if (section.kind === "table") {
-        keys(section, ["kind", "columns", "rows"]);
-        const columns = array(section.columns, 8).map((value3) => text(value3, 80));
-        if (columns.length === 0) throw new Error("table needs columns");
-        const rows = array(section.rows, 100).map((row) => {
-          const cells = array(row, columns.length);
-          if (cells.length !== columns.length) throw new Error("table row width differs from columns");
-          return cells.map((value3) => text(value3, 240));
-        });
-        parsed.sections.push({ kind: "table", columns, rows });
-      } else throw new Error("unsupported panel section");
-    }
-    output.panel = parsed;
-  }
-  return output;
-}
-function extensionPanelText(panel) {
-  return [
-    panel.title,
-    ...panel.sections.flatMap((section) => {
-      if (section.kind === "text") return [section.text];
-      if (section.kind === "metrics") return section.items.map((item) => `${item.label}: ${item.value}`);
-      return [section.columns.join(" | "), ...section.rows.map((row) => row.join(" | "))];
-    })
-  ].join("\n\n");
-}
-
-// src/domains/extensions/discovery.ts
-var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
-var MANIFEST_KEYS = /* @__PURE__ */ new Set(["id", "name", "version", "description", "compatibility", "capabilities", "runtime"]);
-var COMPATIBILITY_KEYS = /* @__PURE__ */ new Set(["clio"]);
-var PLUGIN_OWNED_KEYS = /* @__PURE__ */ new Set(["resources", "skills", "prompts", "agents", "fleets", "themes"]);
-var PLUGIN_GUIDANCE = "domain resources belong in a plugin: clio-coder library install <path>";
-function compareNames(a, b) {
-  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function trimString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function validateId(id) {
-  if (id.length > 80) return "id exceeds 80 characters";
-  if (!/^[a-z0-9][a-z0-9._-]*[a-z0-9]$/.test(id)) {
-    return "id must use lowercase letters, numbers, dots, underscores, or hyphens and start/end alphanumeric";
-  }
-  return null;
-}
-function readJsonOrYaml(filePath) {
-  const raw = readFileSync(filePath, "utf8");
-  if (filePath.endsWith(".json")) return JSON.parse(raw);
-  return (0, import_yaml.parse)(raw);
-}
-function rejectUnknownKeys(value, allowed, label, manifestPath, diagnostics) {
-  for (const key of Object.keys(value).sort()) {
-    if (!allowed.has(key)) {
-      diagnostics.push({ type: "error", message: `unknown ${label} key '${key}'`, path: manifestPath });
-    }
-  }
-}
-function rejectManifestKeys(value, manifestPath, diagnostics) {
-  for (const key of Object.keys(value).sort()) {
-    if (MANIFEST_KEYS.has(key)) continue;
-    diagnostics.push({
-      type: "error",
-      message: PLUGIN_OWNED_KEYS.has(key) ? `harness extensions cannot declare '${key}'; ${PLUGIN_GUIDANCE}` : `unknown manifest key '${key}'`,
-      path: manifestPath
-    });
-  }
-}
-function parseExtensionManifest(value, manifestPath) {
-  const diagnostics = [];
-  if (!isRecord(value)) {
-    return { diagnostics: [{ type: "error", message: "extension manifest must be an object", path: manifestPath }] };
-  }
-  rejectManifestKeys(value, manifestPath, diagnostics);
-  const id = trimString(value.id);
-  const name = trimString(value.name) ?? id;
-  const version = trimString(value.version);
-  const description = trimString(value.description);
-  if (!id) diagnostics.push({ type: "error", message: "id is required", path: manifestPath });
-  else {
-    const idError = validateId(id);
-    if (idError) diagnostics.push({ type: "error", message: idError, path: manifestPath });
-  }
-  if (!version) diagnostics.push({ type: "error", message: "version is required", path: manifestPath });
-  if (!description) diagnostics.push({ type: "error", message: "description is required", path: manifestPath });
-  let capabilities;
-  let runtime;
-  if (value.runtime !== void 0) {
-    try {
-      runtime = parseExtensionRuntime(value.runtime);
-    } catch (error) {
-      diagnostics.push({
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-        path: manifestPath
-      });
-    }
-  }
-  if (value.capabilities !== void 0) {
-    try {
-      capabilities = parseExtensionCapabilities(value.capabilities, id ?? "");
-    } catch (error) {
-      diagnostics.push({
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-        path: manifestPath
-      });
-    }
-  }
-  let compatibility;
-  if (value.compatibility !== void 0) {
-    if (!isRecord(value.compatibility)) {
-      diagnostics.push({ type: "error", message: "compatibility must be an object", path: manifestPath });
-    } else {
-      rejectUnknownKeys(value.compatibility, COMPATIBILITY_KEYS, "compatibility", manifestPath, diagnostics);
-      if (!("clio" in value.compatibility)) {
-        compatibility = {};
-      } else {
-        const range = trimString(value.compatibility.clio);
-        if (range === void 0) {
-          diagnostics.push({
-            type: "error",
-            message: "compatibility.clio must be a non-empty semver range",
-            path: manifestPath
-          });
-        } else {
-          const evaluation = evaluateClioCompatibility(range);
-          if (!evaluation.rangeValid) {
-            diagnostics.push({
-              type: "error",
-              message: `extension ${id ?? "<unknown>"} declares malformed compatibility.clio range '${range}'`,
-              path: manifestPath
-            });
-          } else {
-            compatibility = { clio: range };
-          }
-        }
-      }
-    }
-  }
-  if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
-    return { diagnostics };
-  }
-  const manifest = { id, name, version, description };
-  if (runtime) manifest.runtime = runtime;
-  if (capabilities) manifest.capabilities = capabilities;
-  if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
-  const clioRange = manifest.compatibility?.clio;
-  if (clioRange !== void 0) {
-    const evaluation = evaluateClioCompatibility(clioRange);
-    if (!evaluation.satisfied) {
-      diagnostics.push({
-        type: "error",
-        message: `extension ${manifest.id} requires Clio '${clioRange}', but running Clio version is '${evaluation.runningVersion}'`,
-        path: manifestPath
-      });
-    }
-  }
-  return { manifest, diagnostics };
-}
-function findExtensionManifestPath(root) {
-  for (const name of MANIFEST_NAMES) {
-    const candidate = path2.join(root, name);
-    try {
-      if (statSync(candidate).isFile()) return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function loadManifestFromRoot(root) {
-  const manifestPath = findExtensionManifestPath(root);
-  if (!manifestPath) {
-    return {
-      path: root,
-      valid: false,
-      diagnostics: [{ type: "error", message: "extension manifest not found", path: root }]
-    };
-  }
-  try {
-    const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
-    if (parsed.manifest?.runtime) {
-      try {
-        resolveExtensionEntrypoint(root, parsed.manifest.runtime.entrypoint);
-      } catch (error) {
-        parsed.diagnostics.push({
-          type: "error",
-          message: `runtime: ${error instanceof Error ? error.message : String(error)}`,
-          path: manifestPath
-        });
-      }
-    }
-    for (const tool of parsed.manifest?.capabilities?.tools ?? []) {
-      try {
-        resolveExtensionEntrypoint(root, tool.entrypoint);
-      } catch (error) {
-        parsed.diagnostics.push({
-          type: "error",
-          message: `command tool ${tool.name}: ${error instanceof Error ? error.message : String(error)}`,
-          path: manifestPath
-        });
-      }
-    }
-    return {
-      path: root,
-      manifestPath,
-      ...parsed.manifest ? { manifest: parsed.manifest } : {},
-      valid: parsed.manifest !== void 0 && !parsed.diagnostics.some((diag) => diag.type === "error"),
-      diagnostics: parsed.diagnostics
-    };
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return {
-      path: root,
-      manifestPath,
-      valid: false,
-      diagnostics: [{ type: "error", message: `extension manifest could not be read: ${reason}`, path: manifestPath }]
-    };
-  }
-}
-function discoverExtensionPackages(root) {
-  const full = path2.resolve(root);
-  if (!existsSync(full)) {
-    return [{ path: full, valid: false, diagnostics: [{ type: "error", message: "path does not exist", path: full }] }];
-  }
-  let stat;
-  try {
-    stat = statSync(full);
-  } catch (error) {
-    return [
-      {
-        path: full,
-        valid: false,
-        diagnostics: [
-          {
-            type: "error",
-            message: `extension path could not be inspected: ${error instanceof Error ? error.message : String(error)}`,
-            path: full
-          }
-        ]
-      }
-    ];
-  }
-  if (!stat.isDirectory()) {
-    return [
-      {
-        path: full,
-        valid: false,
-        diagnostics: [{ type: "error", message: "extension path is not a directory", path: full }]
-      }
-    ];
-  }
-  let canonicalFull;
-  try {
-    canonicalFull = realpathSync2(full);
-  } catch (error) {
-    return [
-      {
-        path: full,
-        valid: false,
-        diagnostics: [
-          {
-            type: "error",
-            message: `extension path could not be canonicalized: ${error instanceof Error ? error.message : String(error)}`,
-            path: full
-          }
-        ]
-      }
-    ];
-  }
-  const direct = loadManifestFromRoot(canonicalFull);
-  if (direct.valid || direct.manifestPath) return [direct];
-  const candidates = [];
-  const discoveryFailures = [];
-  const spellingsByCanonicalRoot = /* @__PURE__ */ new Map();
-  let entries;
-  try {
-    entries = readdirSync(canonicalFull, { withFileTypes: true, encoding: "utf8" });
-  } catch (error) {
-    return [
-      {
-        path: canonicalFull,
-        valid: false,
-        diagnostics: [
-          {
-            type: "error",
-            message: `extension directory could not be read: ${error instanceof Error ? error.message : String(error)}`,
-            path: canonicalFull
-          }
-        ]
-      }
-    ];
-  }
-  for (const entry of entries.sort(compareNames)) {
-    if (entry.name.startsWith(".")) continue;
-    const child = path2.join(canonicalFull, entry.name);
-    try {
-      if (!entry.isDirectory() && !(entry.isSymbolicLink() && statSync(child).isDirectory())) continue;
-      const canonicalChild = realpathSync2(child);
-      const spellings = spellingsByCanonicalRoot.get(canonicalChild) ?? [];
-      spellings.push(child);
-      spellingsByCanonicalRoot.set(canonicalChild, spellings);
-    } catch (error) {
-      discoveryFailures.push({
-        path: child,
-        valid: false,
-        diagnostics: [
-          {
-            type: "error",
-            message: `extension child could not be canonicalized: ${error instanceof Error ? error.message : String(error)}`,
-            path: child
-          }
-        ]
-      });
-    }
-  }
-  for (const canonicalChild of [...spellingsByCanonicalRoot.keys()].sort()) {
-    const loaded = loadManifestFromRoot(canonicalChild);
-    const spellings = spellingsByCanonicalRoot.get(canonicalChild) ?? [];
-    if (spellings.length > 1) {
-      loaded.diagnostics.push({
-        type: "warning",
-        message: `duplicate canonical extension root loaded once; discovered as ${spellings.sort().join(", ")}`,
-        path: canonicalChild
-      });
-    }
-    if (loaded.valid || loaded.manifestPath) candidates.push(loaded);
-  }
-  const discovered = [...candidates, ...discoveryFailures].sort(
-    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
-  );
-  if (discovered.length === 0) discovered.push(direct);
-  const ids = /* @__PURE__ */ new Map();
-  for (const candidate of discovered) {
-    const id = candidate.manifest?.id;
-    if (!id) continue;
-    const group = ids.get(id) ?? [];
-    group.push(candidate);
-    ids.set(id, group);
-  }
-  for (const [id, group] of ids) {
-    if (group.length < 2) continue;
-    for (const candidate of group) {
-      candidate.valid = false;
-      candidate.diagnostics.push({
-        type: "error",
-        message: `duplicate extension id ${id}`,
-        path: candidate.manifestPath ?? candidate.path
-      });
-    }
-  }
-  return discovered;
-}
-
-// src/domains/extensions/state.ts
-init_esm_shims();
-import { createHash } from "node:crypto";
-import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync as realpathSync3, renameSync, rmSync } from "node:fs";
-import path3 from "node:path";
-var DEFAULT_STATE = { version: 1, disabled: [], installed: {} };
-function extensionBaseDir(scope, cwd = process.cwd()) {
-  return scope === "user" ? path3.join(clioConfigDir(), "extensions") : path3.join(path3.resolve(cwd), ".clio-coder", "extensions");
-}
-function statePath(scope, cwd = process.cwd()) {
-  return path3.join(extensionBaseDir(scope, cwd), "state.json");
-}
-function recoveryPath(filePath, label) {
-  return `${filePath}.${label}-${process.pid}-${Date.now()}.bak`;
-}
-function packageRecoveryPath(root, label) {
-  return path3.join(path3.dirname(root), `.${path3.basename(root)}.${label}-${process.pid}-${Date.now()}.bak`);
-}
-function preserveFile(filePath, label) {
-  if (!existsSync2(filePath)) return void 0;
-  const backupPath = recoveryPath(filePath, label);
-  safeResourceWrite(backupPath, readFileSync2(filePath));
-  return backupPath;
-}
-function scopeRank(scope) {
-  return scope === "project" ? 2 : 1;
-}
-function readState(scope, cwd = process.cwd()) {
-  const filePath = statePath(scope, cwd);
-  if (!existsSync2(filePath)) return { status: "absent", state: structuredClone(DEFAULT_STATE) };
-  try {
-    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
-    if (!isRecord(parsed) || parsed.version !== 1) throw new Error("state must be a version 1 object");
-    if (!Array.isArray(parsed.disabled) || !parsed.disabled.every((entry) => typeof entry === "string")) {
-      throw new Error("state.disabled must be an array of strings");
-    }
-    if (!isRecord(parsed.installed)) throw new Error("state.installed must be an object");
-    const installed = {};
-    for (const [id, raw] of Object.entries(parsed.installed)) {
-      if (!isRecord(raw)) throw new Error(`state.installed.${id} must be an object`);
-      const installedAt = trimString(raw.installedAt);
-      if (!installedAt) throw new Error(`state.installed.${id}.installedAt must be a non-empty string`);
-      const source = raw.source === void 0 ? void 0 : trimString(raw.source);
-      if (raw.source !== void 0 && !source) {
-        throw new Error(`state.installed.${id}.source must be a non-empty string`);
-      }
-      const contentDigest = raw.contentDigest === void 0 ? void 0 : trimString(raw.contentDigest);
-      if (raw.contentDigest !== void 0 && (!contentDigest || !/^[a-f0-9]{64}$/u.test(contentDigest))) {
-        throw new Error(`state.installed.${id}.contentDigest must be a SHA-256 digest`);
-      }
-      installed[id] = {
-        installedAt,
-        ...source ? { source } : {},
-        ...contentDigest ? { contentDigest } : {}
-      };
-    }
-    return { status: "valid", state: { version: 1, disabled: [...parsed.disabled], installed } };
-  } catch (error) {
-    return {
-      status: "corrupt",
-      state: structuredClone(DEFAULT_STATE),
-      message: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function writeState(scope, state, cwd = process.cwd()) {
-  const filePath = statePath(scope, cwd);
-  safeResourceWrite(filePath, `${JSON.stringify(state, null, 2)}
-`, { encoding: "utf8" });
-}
-function installedFromRoot(root, scope, stateResult, cwd, fallbackId) {
-  const candidate = loadManifestFromRoot(root);
-  const manifest = candidate.manifest;
-  const diagnostics = [...candidate.diagnostics];
-  const id = manifest?.id ?? fallbackId;
-  const provenance = stateResult.state.installed[id];
-  const expectedDigest = provenance?.contentDigest;
-  let observedDigest;
-  let captured;
-  let contentVerified = false;
-  if (stateResult.status === "corrupt") {
-    diagnostics.push({
-      type: "error",
-      message: `extension install state is corrupt: ${stateResult.message}; reinstall with --force or remove the package to preserve the corrupt bytes and recover`,
-      path: statePath(scope, cwd)
-    });
-  } else if (stateResult.status === "absent") {
-    diagnostics.push({
-      type: "error",
-      message: "extension install state is absent; installed content cannot be verified; reinstall with --force",
-      path: statePath(scope, cwd)
-    });
-  } else if (!provenance) {
-    diagnostics.push({
-      type: "error",
-      message: `extension ${id} is not recorded in install state; reinstall with --force`,
-      path: statePath(scope, cwd)
-    });
-  } else if (!expectedDigest) {
-    diagnostics.push({
-      type: "error",
-      message: `extension ${id} install provenance has no content digest; reinstall with --force`,
-      path: statePath(scope, cwd)
-    });
-  } else {
-    try {
-      const manifestName2 = candidate.manifestPath ? path3.basename(candidate.manifestPath) : void 0;
-      const digestResult = extensionContentDigestWithCapture(root, {
-        capture: [...manifestName2 ? [manifestName2] : [], "hooks.yaml"]
-      });
-      observedDigest = digestResult.digest;
-      contentVerified = observedDigest === expectedDigest;
-      if (contentVerified) captured = digestResult.captured;
-      if (!contentVerified) {
-        diagnostics.push({
-          type: "error",
-          message: `installed extension content drift detected (expected ${expectedDigest}, observed ${observedDigest})`,
-          path: root
-        });
-      }
-    } catch (error) {
-      diagnostics.push({
-        type: "error",
-        message: `installed extension content could not be verified: ${error instanceof Error ? error.message : String(error)}`,
-        path: root
-      });
-    }
-  }
-  const clioRange = manifest?.compatibility?.clio;
-  const compatible = clioRange === void 0 || evaluateClioCompatibility(clioRange).satisfied;
-  const manifestName = candidate.manifestPath ? path3.basename(candidate.manifestPath) : void 0;
-  const manifestBytes = manifestName ? captured?.get(manifestName) : void 0;
-  const extensionProvenance = contentVerified && expectedDigest && manifestBytes ? {
-    id,
-    scope,
-    ...provenance?.source ? { sourcePath: provenance.source } : {},
-    canonicalRoot: realpathSync3(root),
-    manifestDigest: createHash("sha256").update(manifestBytes).digest("hex"),
-    contentDigest: expectedDigest
-  } : void 0;
-  const entry = {
-    id,
-    name: manifest?.name ?? id,
-    version: manifest?.version ?? "unknown",
-    description: manifest?.description ?? "Installed extension has an invalid manifest.",
-    ...manifest?.capabilities ? { capabilities: manifest.capabilities } : {},
-    ...manifest?.runtime ? { runtime: manifest.runtime } : {},
-    scope,
-    rootPath: root,
-    manifestPath: candidate.manifestPath ?? root,
-    enabled: !stateResult.state.disabled.includes(id),
-    valid: manifest !== void 0 && candidate.valid && contentVerified,
-    compatible,
-    effective: false,
-    loadable: false,
-    ...extensionProvenance ? { provenance: extensionProvenance } : {},
-    ...observedDigest ? { observedContentDigest: observedDigest } : {},
-    diagnostics
-  };
-  return { entry, ...extensionProvenance && captured ? { captured } : {} };
-}
-function listScope(scope, cwd = process.cwd()) {
-  const base = extensionBaseDir(scope, cwd);
-  if (!existsSync2(base)) return [];
-  const state = readState(scope, cwd);
-  const out = [];
-  for (const entry of readdirSync2(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    const root = path3.join(base, entry.name);
-    const installed = installedFromRoot(root, scope, state, cwd, entry.name);
-    if (installed) out.push(installed);
-  }
-  return out;
-}
-function listInstalledExtensions(cwd = process.cwd(), options = {}) {
-  return listInstalledExtensionRecords(cwd, options).map((record3) => record3.entry);
-}
-function listInstalledExtensionRecords(cwd = process.cwd(), options = {}) {
-  const scopes = options.scope ? [options.scope] : ["user", "project"];
-  const records = scopes.flatMap((scope) => listScope(scope, cwd));
-  const byId = /* @__PURE__ */ new Map();
-  for (const record3 of records) {
-    const entry = record3.entry;
-    const list = byId.get(entry.id) ?? [];
-    list.push(record3);
-    byId.set(entry.id, list);
-  }
-  for (const group of byId.values()) {
-    const winner = group.filter((record3) => record3.entry.valid && record3.entry.compatible).sort((a, b) => scopeRank(a.entry.scope) - scopeRank(b.entry.scope)).at(-1);
-    for (const record3 of group) {
-      const entry = record3.entry;
-      entry.effective = record3 === winner;
-      entry.loadable = entry.valid && entry.compatible && entry.enabled && entry.effective;
-      if (entry.valid && entry.compatible && !entry.effective && winner) entry.overriddenBy = winner.entry.scope;
-    }
-  }
-  const all = options.all === true ? records : records.filter(({ entry }) => entry.effective || !entry.valid || !entry.compatible);
-  return all.sort((a, b) => {
-    const id = a.entry.id.localeCompare(b.entry.id);
-    if (id !== 0) return id;
-    return scopeRank(a.entry.scope) - scopeRank(b.entry.scope);
-  });
-}
-function findInstalled(id, cwd, scope) {
-  const entries = listInstalledExtensions(cwd, { ...scope ? { scope } : {}, all: true }).filter(
-    (entry) => entry.id === id
-  );
-  if (entries.length === 0) return null;
-  return [...entries].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1) ?? null;
-}
-function installExtension(sourcePath, options = {}) {
-  const scope = options.scope ?? "user";
-  const cwd = options.cwd ?? process.cwd();
-  const source = path3.resolve(sourcePath);
-  const candidate = loadManifestFromRoot(source);
-  if (!candidate.manifest || !candidate.valid) return { diagnostics: candidate.diagnostics };
-  const targetRoot = path3.join(extensionBaseDir(scope, cwd), candidate.manifest.id);
-  if (existsSync2(targetRoot)) {
-    if (!options.force) {
-      return {
-        diagnostics: [
-          {
-            type: "error",
-            message: `extension ${candidate.manifest.id} is already installed; retry with --force to replace it`,
-            path: targetRoot
-          }
-        ]
-      };
-    }
-  }
-  const parent = path3.dirname(targetRoot);
-  const stagingRoot = path3.join(parent, `.${candidate.manifest.id}.install-${process.pid}-${Date.now()}`);
-  const backupRoot = path3.join(parent, `.${candidate.manifest.id}.backup-${process.pid}-${Date.now()}`);
-  let installedReplacement = false;
-  let movedExisting = false;
-  const stateResult = readState(scope, cwd);
-  if (stateResult.status === "corrupt" && !options.force) {
-    return {
-      diagnostics: [
-        {
-          type: "error",
-          message: `extension install state is corrupt: ${stateResult.message}; retry with --force to back it up and reinstall safely`,
-          path: statePath(scope, cwd)
-        }
-      ]
-    };
-  }
-  const state = stateResult.status === "corrupt" ? structuredClone(DEFAULT_STATE) : stateResult.state;
-  let stateBackup;
-  let packageBackup;
-  try {
-    mkdirSync(parent, { recursive: true });
-    if (stateResult.status === "corrupt") stateBackup = preserveFile(statePath(scope, cwd), "corrupt");
-    rmSync(stagingRoot, { recursive: true, force: true });
-    rmSync(backupRoot, { recursive: true, force: true });
-    cpSync(source, stagingRoot, {
-      recursive: true,
-      // `state.json` beside the installed extension directories belongs to
-      // Clio's extension manager. An extension may legitimately ship nested
-      // resources with the same basename (for example a project-state JSON
-      // template), so exclude only a bookkeeping file at the package root.
-      filter: (src) => path3.relative(source, src) !== "state.json"
-    });
-    const stagedCandidate = loadManifestFromRoot(stagingRoot);
-    if (!stagedCandidate.valid || !stagedCandidate.manifest) {
-      const reasons = stagedCandidate.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
-      throw new Error(`staged extension content is invalid${reasons ? `: ${reasons}` : ""}`);
-    }
-    if (stagedCandidate.manifest.id !== candidate.manifest.id) {
-      throw new Error(`staged extension id changed from ${candidate.manifest.id} to ${stagedCandidate.manifest.id}`);
-    }
-    const contentDigest = extensionContentDigest(stagingRoot);
-    if (existsSync2(targetRoot)) {
-      renameSync(targetRoot, backupRoot);
-      movedExisting = true;
-      packageBackup = backupRoot;
-    }
-    renameSync(stagingRoot, targetRoot);
-    installedReplacement = true;
-    state.installed[candidate.manifest.id] = {
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      source,
-      contentDigest
-    };
-    state.disabled = state.disabled.filter((entry) => entry !== candidate.manifest?.id);
-    writeState(scope, state, cwd);
-  } catch (error) {
-    rmSync(stagingRoot, { recursive: true, force: true });
-    if (installedReplacement) rmSync(targetRoot, { recursive: true, force: true });
-    if (movedExisting && existsSync2(backupRoot) && !existsSync2(targetRoot)) {
-      renameSync(backupRoot, targetRoot);
-      packageBackup = void 0;
-    }
-    return {
-      ...stateBackup || packageBackup ? { recovery: { ...stateBackup ? { stateBackup } : {}, ...packageBackup ? { packageBackup } : {} } } : {},
-      diagnostics: [
-        {
-          type: "error",
-          message: `extension ${candidate.manifest.id} install failed: ${error instanceof Error ? error.message : String(error)}`,
-          path: targetRoot
-        }
-      ]
-    };
-  }
-  const diagnostics = [...candidate.diagnostics];
-  if (movedExisting && stateResult.status !== "valid") {
-    diagnostics.push({
-      type: "warning",
-      message: "previous unverifiable extension bytes were preserved during forced reinstall",
-      path: backupRoot
-    });
-  } else {
-    try {
-      rmSync(backupRoot, { recursive: true, force: true });
-      packageBackup = void 0;
-    } catch (error) {
-      diagnostics.push({
-        type: "warning",
-        message: `extension installed, but its backup could not be removed: ${error instanceof Error ? error.message : String(error)}`,
-        path: backupRoot
-      });
-    }
-  }
-  if (stateBackup) {
-    diagnostics.push({ type: "warning", message: "corrupt extension install state was preserved", path: stateBackup });
-  }
-  const installed = findInstalled(candidate.manifest.id, cwd, scope);
-  return {
-    ...installed ? { extension: installed } : {},
-    ...stateBackup || packageBackup ? { recovery: { ...stateBackup ? { stateBackup } : {}, ...packageBackup ? { packageBackup } : {} } } : {},
-    diagnostics
-  };
-}
-function mutateEnabled(id, enabled, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const target = findInstalled(id, cwd, options.scope);
-  if (!target) {
-    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
-  }
-  const stateResult = readState(target.scope, cwd);
-  if (stateResult.status !== "valid") {
-    return {
-      diagnostics: [
-        {
-          type: "error",
-          message: stateResult.status === "corrupt" ? `extension install state is corrupt: ${stateResult.message}` : "extension install state is absent",
-          path: statePath(target.scope, cwd)
-        }
-      ]
-    };
-  }
-  const state = stateResult.state;
-  if (enabled) state.disabled = state.disabled.filter((entry) => entry !== id);
-  else if (!state.disabled.includes(id)) state.disabled.push(id);
-  writeState(target.scope, state, cwd);
-  const extension = findInstalled(id, cwd, target.scope) ?? void 0;
-  return { ...extension ? { extension } : {}, diagnostics: [] };
-}
-function enableExtension(id, options = {}) {
-  return mutateEnabled(id, true, options);
-}
-function disableExtension(id, options = {}) {
-  return mutateEnabled(id, false, options);
-}
-function removeExtension(id, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const target = findInstalled(id, cwd, options.scope);
-  if (!target) {
-    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
-  }
-  const stateResult = readState(target.scope, cwd);
-  if (stateResult.status !== "valid") {
-    const filePath = statePath(target.scope, cwd);
-    const packageBackup = packageRecoveryPath(target.rootPath, "removed-unverifiable");
-    let stateBackup;
-    try {
-      if (stateResult.status === "corrupt") stateBackup = preserveFile(filePath, "corrupt");
-      renameSync(target.rootPath, packageBackup);
-      try {
-        writeState(target.scope, structuredClone(DEFAULT_STATE), cwd);
-      } catch (error) {
-        renameSync(packageBackup, target.rootPath);
-        throw error;
-      }
-      const diagnostics = [
-        {
-          type: "warning",
-          message: "unverifiable extension bytes were preserved while removing the package from the load path",
-          path: packageBackup
-        }
-      ];
-      if (stateBackup) {
-        diagnostics.push({ type: "warning", message: "corrupt extension install state was preserved", path: stateBackup });
-      }
-      return {
-        removed: { id, scope: target.scope, path: target.rootPath },
-        recovery: { ...stateBackup ? { stateBackup } : {}, packageBackup },
-        diagnostics
-      };
-    } catch (error) {
-      return {
-        diagnostics: [
-          {
-            type: "error",
-            message: `extension ${id} could not be removed safely: ${error instanceof Error ? error.message : String(error)}`,
-            path: target.rootPath
-          }
-        ]
-      };
-    }
-  }
-  const state = stateResult.state;
-  rmSync(target.rootPath, { recursive: true, force: true });
-  Reflect.deleteProperty(state.installed, id);
-  state.disabled = state.disabled.filter((entry) => entry !== id);
-  writeState(target.scope, state, cwd);
-  return { removed: { id, scope: target.scope, path: target.rootPath }, diagnostics: [] };
-}
-
-export {
-  extensionToolName,
-  resolveExtensionEntrypoint,
-  RUNTIME_LIMITS,
-  extensionPlainText,
-  parseExtensionOutput,
-  extensionPanelText,
-  parseExtensionManifest,
-  loadManifestFromRoot,
-  discoverExtensionPackages,
-  extensionBaseDir,
-  listInstalledExtensions,
-  listInstalledExtensionRecords,
-  installExtension,
-  enableExtension,
-  disableExtension,
-  removeExtension
-};
-//# sourceMappingURL=chunk-6TKOFFGE.js.map