@iowarp/clio-coder 0.3.6 → 0.3.8

package/dist/{chunk-VEZEGCGW.js → chunk-B5CSFE7B.js}

@@ -2,16 +2,32 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   clampTimerDelayMs
 } from "./chunk-FQ4SKYE4.js";
-import {
-  clioStateDir
-} from "./chunk-BNAZZHFG.js";
 import {
   AI_AGENT_NAME
 } from "./chunk-6EJMN2Y3.js";
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
+// src/core/git-commit-attribution.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import {
+  accessSync,
+  chmodSync,
+  existsSync,
+  constants as fsConstants,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { join, resolve } from "node:path";
+
 // src/core/commit-attribution.ts
 init_esm_shims();
 var CLIO_COMMIT_IDENTITY = "Clio Coder <clio-coder@iowarp.ai>";
@@ -32,7 +48,7 @@ var KNOWN_CLIO_TRAILERS = new Set(
   Object.values(CLIO_COMMIT_TRAILERS).map((line) => normalizedTrailer(line)).filter((line) => line !== null)
 );
 function isClioTrailer(key) {
-  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v15/sha256:");
+  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v20/sha256:");
 }
 function trailerBlockStart(lines) {
   if (lines.length < 2) return null;
@@ -51,10 +67,10 @@ function trailerBlockStart(lines) {
   return sawTrailer ? first : null;
 }
 function receiptTrailer(receipt) {
-  if (receipt?.version !== 15 || receipt.algorithm !== "sha256" || receipt.integrityValid !== true || receipt.directlyRelevant !== true || !SHA256.test(receipt.digest)) {
+  if (receipt?.version !== 20 || receipt.algorithm !== "sha256" || receipt.integrityValid !== true || receipt.directlyRelevant !== true || !SHA256.test(receipt.digest)) {
     return null;
   }
-  return `Clio-Evidence: receipt-v15/sha256:${receipt.digest}`;
+  return `Clio-Evidence: receipt-v20/sha256:${receipt.digest}`;
 }
 function attributeCommitMessage(originalMessage, evidence, enabled = true) {
   if (!enabled) return originalMessage;
@@ -96,20 +112,6 @@ function attributeCommitMessage(originalMessage, evidence, enabled = true) {
 }
 
 // src/core/git-commit-attribution.ts
-init_esm_shims();
-import { execFileSync } from "node:child_process";
-import {
-  accessSync,
-  chmodSync,
-  existsSync,
-  constants as fsConstants,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync
-} from "node:fs";
-import { join, resolve } from "node:path";
 var CLIO_GIT_COMMITS_ENABLED_ENV = "CLIO_CODER_GIT_COMMITS_ENABLED";
 var ASSISTED_ENV = "CLIO_CODER_COMMIT_ASSISTED";
 var AUTHORED_ENV = "CLIO_CODER_COMMIT_AUTHORED";
@@ -565,4 +567,4 @@ export {
   runCommandVector,
   combineSafeOutput
 };
-//# sourceMappingURL=chunk-VEZEGCGW.js.map
+//# sourceMappingURL=chunk-B5CSFE7B.js.map

package/dist/{chunk-2SFS6XQE.js → chunk-DGSYXYMX.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   enabledExtensionResourceRoots
-} from "./chunk-ZWLZP4ZT.js";
+} from "./chunk-DYIM5TJT.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -29,6 +29,7 @@ function defaultScopedResourceRoots(kind, cwd) {
   return [
     ...enabledExtensionResourceRoots(kind, cwd).map((root) => ({
       path: root.path,
+      rootPath: root.rootPath,
       scope: "package",
       source: root.source,
       precedence: COMPAT_RESOURCE_PRECEDENCE.extension
@@ -119,4 +120,4 @@ export {
   splitYamlFrontmatter,
   stringField
 };
-//# sourceMappingURL=chunk-2SFS6XQE.js.map
+//# sourceMappingURL=chunk-DGSYXYMX.js.map

package/dist/chunk-DR52UMZW.js

@@ -0,0 +1,21 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/config/agent-namespace.ts
+init_esm_shims();
+function assertAgentIdNamespace(nativeRecipes, acpDelegates) {
+  const native = new Set(nativeRecipes.map((recipe) => recipe.id));
+  const collision = acpDelegates.find((delegate) => native.has(delegate.id));
+  if (collision !== void 0) {
+    throw new Error(
+      `agent id collision: native recipe '${collision.id}' and ACP delegation agent '${collision.id}' share one namespace`
+    );
+  }
+}
+
+export {
+  assertAgentIdNamespace
+};
+//# sourceMappingURL=chunk-DR52UMZW.js.map

package/dist/{chunk-ZWLZP4ZT.js → chunk-DYIM5TJT.js}

@@ -16,7 +16,7 @@ import {
 // src/domains/extensions/discovery.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
 function isRecord(value) {
@@ -44,12 +44,85 @@ function normalizeResources(value) {
   const out = {};
   const skills = trimString(value.skills);
   const prompts = trimString(value.prompts);
+  const agents = trimString(value.agents);
+  const fleets = trimString(value.fleets);
   const themes = trimString(value.themes);
   if (skills) out.skills = skills;
   if (prompts) out.prompts = prompts;
+  if (agents) out.agents = agents;
+  if (fleets) out.fleets = fleets;
   if (themes) out.themes = themes;
   return out;
 }
+function contained(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+function validateResourceTree(root, resourcePath, kind, diagnostics) {
+  if (path.isAbsolute(resourcePath)) {
+    diagnostics.push({ type: "error", message: `resources.${kind} must be relative`, path: resourcePath });
+    return;
+  }
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(resolvedRoot, resourcePath);
+  if (!contained(resolvedRoot, resolved) || resolved === resolvedRoot) {
+    diagnostics.push({ type: "error", message: `resources.${kind} escapes the extension root`, path: resourcePath });
+    return;
+  }
+  let canonicalRoot;
+  let canonicalResource;
+  try {
+    canonicalRoot = realpathSync(resolvedRoot);
+    canonicalResource = realpathSync(resolved);
+    if (!lstatSync(resolved).isDirectory()) {
+      diagnostics.push({ type: "error", message: `resources.${kind} is not a directory`, path: resolved });
+      return;
+    }
+  } catch (error) {
+    diagnostics.push({
+      type: "error",
+      message: `resources.${kind} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`,
+      path: resolved
+    });
+    return;
+  }
+  if (!contained(canonicalRoot, canonicalResource)) {
+    diagnostics.push({ type: "error", message: `resources.${kind} escapes through a symbolic link`, path: resolved });
+    return;
+  }
+  const pending = [resolved];
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    if (!directory) continue;
+    for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const candidate = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        try {
+          if (!contained(canonicalRoot, realpathSync(candidate))) {
+            diagnostics.push({
+              type: "error",
+              message: `resources.${kind} contains an escaping symbolic link`,
+              path: candidate
+            });
+          }
+        } catch (error) {
+          diagnostics.push({
+            type: "error",
+            message: `resources.${kind} contains an unresolved symbolic link: ${error instanceof Error ? error.message : String(error)}`,
+            path: candidate
+          });
+        }
+      } else if (entry.isDirectory()) {
+        pending.push(candidate);
+      }
+    }
+  }
+}
+function validateResourceRoots(root, resources, diagnostics) {
+  for (const [kind, resourcePath] of Object.entries(resources)) {
+    if (resourcePath) validateResourceTree(root, resourcePath, kind, diagnostics);
+  }
+}
 function stringArray(value) {
   if (!Array.isArray(value)) return void 0;
   const out = value.map((entry) => trimString(entry)).filter((entry) => entry !== void 0);
@@ -115,6 +188,7 @@ function loadManifestFromRoot(root) {
   }
   try {
     const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
+    if (parsed.manifest) validateResourceRoots(root, parsed.manifest.resources, parsed.diagnostics);
     return {
       path: root,
       manifestPath,
@@ -284,7 +358,7 @@ function installExtension(sourcePath, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const source = path2.resolve(sourcePath);
   const candidate = loadManifestFromRoot(source);
-  if (!candidate.manifest) return { diagnostics: candidate.diagnostics };
+  if (!candidate.manifest || !candidate.valid) return { diagnostics: candidate.diagnostics };
   const targetRoot = path2.join(extensionBaseDir(scope, cwd), candidate.manifest.id);
   if (existsSync2(targetRoot)) {
     if (!options.force) {
@@ -307,7 +381,11 @@ function installExtension(sourcePath, options = {}) {
     rmSync(backupRoot, { recursive: true, force: true });
     cpSync(source, stagingRoot, {
       recursive: true,
-      filter: (src) => path2.basename(src) !== "state.json"
+      // `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) => path2.relative(source, src) !== "state.json"
     });
     if (existsSync2(targetRoot)) {
       renameSync(targetRoot, backupRoot);
@@ -379,14 +457,26 @@ init_esm_shims();
 
 // src/domains/extensions/resources.ts
 init_esm_shims();
-import { statSync as statSync2 } from "node:fs";
+import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
 import path3 from "node:path";
 function extensionResourcePath(rootPath, resourcePath) {
   const root = path3.resolve(rootPath);
   const full = path3.resolve(root, resourcePath);
   const relative = path3.relative(root, full);
-  if (relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative)) return full;
-  return null;
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative))
+    return null;
+  try {
+    const rootReal = realpathSync2(root);
+    const fullReal = realpathSync2(full);
+    const canonicalRelative = path3.relative(rootReal, fullReal);
+    if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${path3.sep}`) || path3.isAbsolute(canonicalRelative)) {
+      return null;
+    }
+    if (!lstatSync2(full).isDirectory()) return null;
+    return full;
+  } catch {
+    return null;
+  }
 }
 function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
   const roots = [];
@@ -396,15 +486,11 @@ function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
     if (!rel) continue;
     const full = extensionResourcePath(entry.rootPath, rel);
     if (!full) continue;
-    try {
-      if (!statSync2(full).isDirectory()) continue;
-    } catch {
-      continue;
-    }
     roots.push({
       id: entry.id,
       scope: entry.scope,
       path: full,
+      rootPath: entry.rootPath,
       source: `extension:${entry.scope}:${entry.id}`
     });
   }
@@ -474,4 +560,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-ZWLZP4ZT.js.map
+//# sourceMappingURL=chunk-DYIM5TJT.js.map