@cleocode/caamp 2026.5.84 → 2026.5.86

package/dist/cli.js

@@ -44,6 +44,7 @@ import {
   recommendSkills,
   recordSkillInstall,
   registerDoctorBridge,
+  registerSkillsDoctorAdopt,
   removeMcpServer,
   removeMcpServerFromAll,
   removeSkillFromLock,
@@ -60,7 +61,7 @@ import {
   tokenizeCriteriaValue,
   updateInstructionsSingleOperation,
   validateSkill
-} from "./chunk-QSJSM57K.js";
+} from "./chunk-WXL7RPS4.js";
 import {
   buildSkillsMap,
   checkAllInjections,
@@ -4394,6 +4395,76 @@ Show example inputs and expected outputs.
 // src/commands/skills/install.ts
 import { existsSync as existsSync12 } from "fs";
 import pc12 from "picocolors";
+
+// src/core/skills/trust-gate-adapter.ts
+var cachedCore;
+async function resolveCore() {
+  if (cachedCore !== void 0) return cachedCore;
+  try {
+    const mod = await import("@cleocode/core");
+    cachedCore = mod;
+  } catch {
+    cachedCore = null;
+    process.stderr.write(
+      "[caamp] WARNING: @cleocode/core unavailable \u2014 skipping trust gate (skill installs not security-checked)\n"
+    );
+  }
+  return cachedCore;
+}
+async function evaluateSkillTrustGate(localPath, source, force = false) {
+  const core = await resolveCore();
+  if (!core) {
+    return {
+      decision: "allow",
+      reason: "Trust gate skipped \u2014 @cleocode/core not available",
+      scan: {
+        skillName: localPath.split("/").filter(Boolean).pop() ?? localPath,
+        source,
+        trustLevel: "community",
+        verdict: "safe",
+        findings: [],
+        scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        summary: "core-unavailable"
+      }
+    };
+  }
+  const scan = core.scanSkill(localPath, source);
+  const gate = core.shouldAllowInstall(scan, force);
+  return { decision: gate.decision, reason: gate.reason, scan };
+}
+async function evaluateFederationGate(source, opts = {}) {
+  const core = await resolveCore();
+  if (!core) {
+    return {
+      decision: "allow",
+      reason: "Federation gate skipped \u2014 @cleocode/core not available",
+      peer: null,
+      isFederationSource: false,
+      computedChecksum: null,
+      expectedChecksum: null
+    };
+  }
+  return core.evaluateFederationInstallGate({
+    source,
+    artefactPath: opts.artefactPath,
+    expectedChecksum: opts.expectedChecksum,
+    approveNewSource: opts.approveNewSource
+  });
+}
+async function recordSkillTrustBypass(scan, reason = null) {
+  const core = await resolveCore();
+  if (!core) return;
+  try {
+    core.recordTrustBypass(scan, reason);
+  } catch (err) {
+    process.stderr.write(
+      `[caamp] WARNING: failed to record trust-bypass audit row: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+
+// src/commands/skills/install.ts
 function registerSkillsInstall(parent) {
   parent.command("install").description("Install a skill from GitHub, URL, marketplace, or registered skill library").argument("[source]", "Skill source (GitHub URL, owner/repo, @author/name, skill-name)").option(
     "-a, --agent <name>",
@@ -4403,6 +4474,12 @@ function registerSkillsInstall(parent) {
   ).option("-g, --global", "Install globally").option("-y, --yes", "Skip confirmation").option("--all", "Install to all detected agents").option(
     "--profile <name>",
     "Install a skill library profile (minimal, core, recommended, full)"
+  ).option(
+    "--force",
+    "Override trust-gate block decisions (audited to .cleo/audit/skill-trust-bypass.jsonl)"
+  ).option(
+    "--allow-new-source",
+    "Bypass first-install confirmation prompt for unknown federation sources (non-TTY safe)"
   ).option("--json", "Output as JSON (default)").option("--human", "Output in human-readable format").action(
     async (source, opts) => {
       const operation = "skills.install";
@@ -4629,6 +4706,100 @@ function registerSkillsInstall(parent) {
           console.error(pc12.red(message));
           process.exit(1);
         }
+        if (sourceType !== "library" && sourceType !== "package") {
+          const fedGate = await evaluateFederationGate(sourceValue, {
+            artefactPath: localPath,
+            approveNewSource: opts.allowNewSource === true
+          });
+          if (fedGate.decision === "block-checksum") {
+            const message = `Federation install blocked: ${fedGate.reason}`;
+            if (format === "json") {
+              emitJsonError(
+                operation,
+                mvi,
+                ErrorCodes.FEDERATION_CHECKSUM_MISMATCH,
+                message,
+                ErrorCategories.VALIDATION,
+                {
+                  expectedChecksum: fedGate.expectedChecksum,
+                  computedChecksum: fedGate.computedChecksum
+                }
+              );
+            }
+            console.error(pc12.red(message));
+            process.exit(1);
+          }
+          if (fedGate.decision === "prompt-first-install") {
+            const message = `${fedGate.reason} Use --allow-new-source to approve in non-interactive contexts.`;
+            if (format === "json") {
+              emitJsonError(
+                operation,
+                mvi,
+                ErrorCodes.FEDERATION_UNKNOWN_SOURCE_INTERACTIVE_REQUIRED,
+                message,
+                ErrorCategories.VALIDATION,
+                { peer: fedGate.peer?.url ?? null }
+              );
+            }
+            console.error(pc12.yellow(message));
+            process.exit(1);
+          }
+        }
+        if (sourceType !== "library" && sourceType !== "package") {
+          const gate = await evaluateSkillTrustGate(localPath, sourceValue, opts.force ?? false);
+          if (gate.decision === "block") {
+            const message = `Trust gate blocked install: ${gate.reason}`;
+            if (format === "json") {
+              const envelope = buildEnvelope(
+                operation,
+                mvi,
+                { scan: gate.scan },
+                {
+                  code: ErrorCodes.SKILL_TRUST_GATE_BLOCKED,
+                  message,
+                  category: ErrorCategories.VALIDATION,
+                  retryable: false,
+                  retryAfterMs: null,
+                  details: {
+                    verdict: gate.scan.verdict,
+                    trustLevel: gate.scan.trustLevel,
+                    findingsCount: gate.scan.findings.length
+                  }
+                }
+              );
+              console.error(JSON.stringify(envelope, null, 2));
+            } else {
+              console.error(pc12.red(`
+${message}`));
+              for (const f of gate.scan.findings.slice(0, 5)) {
+                console.error(
+                  pc12.dim(
+                    `  [${f.severity}] ${f.category} ${f.file}:${f.line} \u2014 ${f.description}`
+                  )
+                );
+              }
+              console.error(pc12.yellow("  Use --force to override (audited)."));
+            }
+            process.exit(1);
+          }
+          if (gate.decision === "ask") {
+            const message = `Trust gate requires confirmation: ${gate.reason}`;
+            if (format === "json") {
+              emitJsonError(
+                operation,
+                mvi,
+                ErrorCodes.SKILL_TRUST_GATE_BLOCKED,
+                message,
+                ErrorCategories.VALIDATION
+              );
+            }
+            console.error(pc12.red(message));
+            process.exit(1);
+          }
+          if (opts.force === true && gate.scan.verdict !== "safe") {
+            await recordSkillTrustBypass(gate.scan, "operator --force on caamp skills install");
+          }
+        }
         const result = await dispatchInstallSkillAcrossProviders(
           localPath,
           skillName,
@@ -5411,6 +5582,7 @@ function registerSkillsCommands(program2) {
   registerSkillsValidate(skills);
   registerSkillsDoctorMigrate(skills);
   registerSkillsDoctor(skills);
+  registerSkillsDoctorAdopt(skills);
 }
 
 // src/cli.ts