npm - chainlesschain - Versions diffs - 0.166.22 → 0.166.25 - Mend

chainlesschain 0.166.22 → 0.166.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (298) hide show

package/src/lib/evolution/governed-skill-marketplace-badge.js ADDED Viewed

@@ -0,0 +1,208 @@
+import { createHash } from "node:crypto";
+import { createServer } from "node:http";
+import { isIP } from "node:net";
+import { isGovernedSkillMarketplaceCliHost } from "./governed-skill-marketplace-cli-host.js";
+const STYLE = `:root{color-scheme:light dark;font-family:system-ui,sans-serif;background:#f4f6fa;color:#152238}body{margin:0;padding:32px 16px}main{max-width:880px;margin:auto;background:#fff;padding:28px;border:1px solid #dde3ec;border-radius:16px}h1{margin:8px 0}.eyebrow{letter-spacing:.08em;color:#50627b}.status{display:inline-block;padding:6px 12px;border-radius:20px;background:#e8f5ec;color:#21623b}.revoked{background:#fdebec;color:#952a35}.score{font-size:32px;font-weight:650}.muted{color:#50627b}.notice{padding:14px;background:#f1f4fa;border-radius:8px}dl{display:grid;grid-template-columns:180px minmax(0,1fr);gap:12px;margin:24px 0}dt{font-weight:600}dd{margin:0;overflow-wrap:anywhere}code{font-size:.85em}a{color:#225caa}footer{margin-top:24px;font-size:.9em}@media(max-width:560px){main{padding:18px}dl{grid-template-columns:1fr;gap:6px}dd{margin-bottom:12px}}@media(prefers-color-scheme:dark){:root{background:#101722;color:#e1e8f2}main{background:#172231;border-color:#344154}.muted,.eyebrow{color:#afbed2}.notice{background:#233147}a{color:#96bfff}}`;
+const CSP = `default-src 'none'; style-src 'sha256-${createHash("sha256").update(STYLE).digest("base64")}'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`;
+function escapeHtml(value) {
+  return String(value ?? "").replace(
+    /[&<>"']/g,
+    (character) =>
+      ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;",
+      })[character],
+  );
+}
+export function renderGovernedSkillMarketplaceBadge(badge) {
+  const rows = [
+    [
+      "目标模型 / OS / 工具 / runtime",
+      [
+        badge.target.model,
+        badge.target.os,
+        badge.target.tool,
+        badge.target.runtime,
+      ].join(" / "),
+    ],
+    ["来源模型", badge.sourceModel],
+    ["签名目录摘要", badge.manifestDigest],
+    ["目标评测凭证", badge.evalReceiptDigest],
+    ["Eval badge 摘要", badge.evalBadgeDigest],
+    ["来源 commit 摘要", badge.sourceCommitDigest],
+    [
+      "原始包 / 适配包",
+      `${badge.packageDigest} / ${badge.adaptedOutputDigest}`,
+    ],
+    ["SBOM 摘要", badge.sbomDigest],
+    ["依赖锁摘要", badge.dependencyLockDigest],
+    ["权限清单摘要", badge.permissionManifestDigest],
+    ["兼容矩阵摘要", badge.targetMatrixDigest],
+    ["发布时核验", badge.verifiedAt],
+    ["快照有效至", badge.expiresAt],
+    ["本次状态检查", badge.checkedAt],
+  ];
+  const status = badge.revoked ? "已撤销 · 不可用于安装" : "已核验的评测快照";
+  return `<!doctype html>
+<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(badge.skillName)} · Skill 评测凭证</title><style>${STYLE}</style></head>
+<body><main><p class="eyebrow">CHAINLESSCHAIN · EVAL BADGE</p><h1>${escapeHtml(badge.skillName)} <small>@ ${escapeHtml(badge.version)}</small></h1>
+<p class="status${badge.revoked ? " revoked" : ""}">${status}</p><p><span class="score">${escapeHtml((badge.qualityScore * 100).toFixed(1))}%</span> 目标评分 · ${escapeHtml(badge.sampleCount)} 个样本</p>
+<p class="notice">此页展示发布时的目标评测与适配核验结果。目录签名和已记录撤销在每次访问时重新检查；其他 authority 的后续撤销不由此快照证明。页面不代表已安装、已启用或新的运行授权。</p>
+<dl>${rows.map(([label, value]) => `<dt>${escapeHtml(label)}</dt><dd><code>${escapeHtml(value)}</code></dd>`).join("\n")}</dl>
+<p><a href="/badge.json">查看公开 JSON 投影</a></p><footer class="muted">仅公开必要元数据与证据摘要，不公开租户、候选内容、签名原文或私有回执。独立复核和复现需要发布者另行提供原始签名证据及可公开的评测材料。</footer></main></body></html>`;
+}
+function integer(value, label, min, max) {
+  if (!Number.isSafeInteger(value) || value < min || value > max)
+    throw new TypeError(`${label} is out of range`);
+}
+/** Publish one explicitly selected immutable listing; no browse or mutation API. */
+export async function startGovernedSkillMarketplaceBadgeServer({
+  marketplaceHost,
+  skillName,
+  version,
+  manifestDigest,
+  listen = "127.0.0.1",
+  port = 8321,
+  snapshotTtlMs = 600_000,
+  requestTimeoutMs = 5_000,
+  maxConcurrentRequests = 4,
+  now = Date.now,
+} = {}) {
+  if (!isGovernedSkillMarketplaceCliHost(marketplaceHost))
+    throw new TypeError("public badges require a branded marketplace host");
+  if (!isIP(listen))
+    throw new TypeError("badge listen address must be an IP literal");
+  integer(port, "badge port", 0, 65535);
+  integer(snapshotTtlMs, "badge snapshot TTL", 1_000, 3_600_000);
+  integer(requestTimeoutMs, "badge request timeout", 10, 30_000);
+  integer(maxConcurrentRequests, "badge concurrency", 1, 16);
+  if (typeof now !== "function") throw new TypeError("badge clock is required");
+  const timestamp = () => {
+    const value = now();
+    if (
+      !Number.isSafeInteger(value) ||
+      value < 0 ||
+      value > 8_640_000_000_000_000 - snapshotTtlMs
+    )
+      throw new Error("badge clock is invalid");
+    return value;
+  };
+  const reader = await marketplaceHost.preparePublicBadge({
+    skillName,
+    version,
+    manifestDigest,
+  });
+  await reader.read();
+  const verifiedAt = timestamp();
+  const expiresAt = verifiedAt + snapshotTtlMs;
+  let inFlight = 0;
+  const server = createServer({ maxHeaderSize: 8192 }, (request, response) => {
+    response.setHeader("Cache-Control", "no-store, max-age=0");
+    response.setHeader("Content-Security-Policy", CSP);
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    response.setHeader("X-Frame-Options", "DENY");
+    response.setHeader("Referrer-Policy", "no-referrer");
+    const finish = (status, body, type = "text/plain; charset=utf-8") => {
+      if (response.writableEnded || response.destroyed) return;
+      response.statusCode = status;
+      response.setHeader("Content-Type", type);
+      response.end(request.method === "HEAD" ? undefined : body);
+    };
+    if (!["GET", "HEAD"].includes(request.method)) {
+      response.setHeader("Allow", "GET, HEAD");
+      response.setHeader("Connection", "close");
+      finish(405, "Read-only badge endpoint.");
+      return;
+    }
+    if (
+      request.headers["transfer-encoding"] ||
+      (request.headers["content-length"] &&
+        request.headers["content-length"] !== "0")
+    ) {
+      response.setHeader("Connection", "close");
+      finish(400, "Request bodies are not accepted.");
+      return;
+    }
+    if (request.url !== "/" && request.url !== "/badge.json") {
+      finish(404, "Badge endpoint not found.");
+      return;
+    }
+    if (inFlight >= maxConcurrentRequests) {
+      response.setHeader("Retry-After", "5");
+      finish(429, "Badge verification is busy.");
+      return;
+    }
+    inFlight += 1;
+    const timer = setTimeout(
+      () => finish(503, "Badge verification is unavailable."),
+      requestTimeoutMs,
+    );
+    Promise.resolve()
+      .then(async () => {
+        const before = timestamp();
+        if (before < verifiedAt || before >= expiresAt)
+          throw new Error("snapshot expired");
+        const current = await reader.read();
+        const checkedAt = timestamp();
+        if (checkedAt < before || checkedAt >= expiresAt)
+          throw new Error("snapshot expired");
+        const badge = {
+          ...current,
+          verifiedAt: new Date(verifiedAt).toISOString(),
+          expiresAt: new Date(expiresAt).toISOString(),
+          checkedAt: new Date(checkedAt).toISOString(),
+        };
+        if (request.url === "/badge.json")
+          finish(
+            200,
+            `${JSON.stringify(badge, null, 2)}\n`,
+            "application/json; charset=utf-8",
+          );
+        else
+          finish(
+            200,
+            renderGovernedSkillMarketplaceBadge(badge),
+            "text/html; charset=utf-8",
+          );
+      })
+      .catch(() => finish(503, "Badge verification is unavailable."))
+      .finally(() => {
+        clearTimeout(timer);
+        // A timed-out underlying verifier retains its slot until it settles.
+        inFlight -= 1;
+      });
+  });
+  server.maxConnections = 32;
+  server.maxRequestsPerSocket = 16;
+  server.headersTimeout = 5_000;
+  server.requestTimeout = 5_000;
+  server.keepAliveTimeout = 1_000;
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, listen, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const hostname =
+    isIP(address.address) === 6 ? `[${address.address}]` : address.address;
+  let closing;
+  return Object.freeze({
+    server,
+    url: `http://${hostname}:${address.port}/`,
+    close: () =>
+      (closing ??= new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+        server.closeAllConnections();
+      })),
+  });
+}

package/src/lib/evolution/governed-skill-marketplace-candidate.js ADDED Viewed

@@ -0,0 +1,330 @@
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { types as utilTypes } from "node:util";
+import {
+  SkillCandidateRegistry,
+  SKILL_CANDIDATE_MAX_ARTIFACT_BYTES,
+  verifySkillCandidateDraft,
+} from "./skill-candidate-registry.js";
+export const GOVERNED_SKILL_MARKETPLACE_CANDIDATE_BINDING_SCHEMA =
+  "chainlesschain.governed-skill-marketplace-candidate-binding/v1";
+const INSTALLERS = new WeakSet();
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const BINDING_DIGESTS = [
+  "manifestDigest",
+  "packageDigest",
+  "adaptedOutputDigest",
+  "candidateId",
+  "contentDigest",
+  "dependencyLockDigest",
+  "runtimeManifestDigest",
+  "targetMatrixRoot",
+  "sbomDigest",
+  "permissionManifestDigest",
+  "bindingDigest",
+];
+const BINDING_KEYS = new Set([
+  "schema",
+  "tenantId",
+  "skillName",
+  ...BINDING_DIGESTS,
+]);
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+function hash(bytes) {
+  return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+function bindingDigest(core) {
+  return hash(
+    `${GOVERNED_SKILL_MARKETPLACE_CANDIDATE_BINDING_SCHEMA}\0${canonical(core)}`,
+  );
+}
+export function serializeGovernedSkillMarketplaceCandidatePackage(candidate) {
+  return Buffer.from(
+    `${canonical(verifySkillCandidateDraft(candidate))}\n`,
+    "utf8",
+  );
+}
+export function digestGovernedSkillMarketplaceCandidatePermissions(candidate) {
+  const verified = verifySkillCandidateDraft(candidate);
+  return hash(
+    `chainlesschain.governed-skill-marketplace-permissions/v1\0${canonical({
+      tenantId: verified.tenantId,
+      skillName: verified.skillName,
+      requestedCapabilities: verified.requestedCapabilities,
+    })}`,
+  );
+}
+export function verifyGovernedSkillMarketplaceCandidateBinding(
+  value,
+  expected,
+) {
+  if (
+    !value ||
+    utilTypes.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  )
+    throw new TypeError("marketplace candidate binding is invalid");
+  const keys = Reflect.ownKeys(value);
+  if (
+    keys.length !== BINDING_KEYS.size ||
+    keys.some((key) => !BINDING_KEYS.has(key))
+  )
+    throw new TypeError("marketplace candidate binding has invalid fields");
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      !descriptor ||
+      !Object.hasOwn(descriptor, "value") ||
+      !descriptor.enumerable
+    )
+      throw new TypeError(
+        "marketplace candidate binding must contain data fields",
+      );
+  }
+  const { bindingDigest: supplied, ...core } = value;
+  if (
+    value.schema !== GOVERNED_SKILL_MARKETPLACE_CANDIDATE_BINDING_SCHEMA ||
+    BINDING_DIGESTS.some(
+      (key) => typeof value[key] !== "string" || !DIGEST.test(value[key]),
+    ) ||
+    supplied !== bindingDigest(core) ||
+    [
+      "tenantId",
+      "skillName",
+      "manifestDigest",
+      "packageDigest",
+      "adaptedOutputDigest",
+    ].some((key) => value[key] !== expected[key])
+  )
+    throw new Error("marketplace candidate binding does not match its state");
+  return Object.freeze({ ...value });
+}
+function bytes(value, expectedDigest, name) {
+  if (
+    utilTypes.isProxy(value) ||
+    !Buffer.isBuffer(value) ||
+    value.length === 0 ||
+    value.length > SKILL_CANDIDATE_MAX_ARTIFACT_BYTES
+  )
+    throw new TypeError(`marketplace ${name} must be bounded bytes`);
+  const snapshot = Buffer.from(value);
+  if (hash(snapshot) !== expectedDigest)
+    throw new Error(`marketplace ${name} digest mismatch`);
+  return snapshot;
+}
+function parsePackage(value) {
+  let candidate;
+  try {
+    candidate = verifySkillCandidateDraft(
+      JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(value)),
+    );
+  } catch (cause) {
+    throw new Error(
+      "marketplace package is not a verified Candidate v2 artifact",
+      { cause },
+    );
+  }
+  if (
+    !serializeGovernedSkillMarketplaceCandidatePackage(candidate).equals(value)
+  )
+    throw new Error("marketplace candidate package is not canonical");
+  return candidate;
+}
+function matchManifest(candidate, manifest) {
+  if (
+    candidate.tenantId !== manifest.tenantId ||
+    candidate.skillName !== manifest.skillName ||
+    candidate.dependencyLockDigest !== manifest.dependencyLockDigest ||
+    candidate.targetMatrixRoot !== manifest.targetMatrixDigest ||
+    digestGovernedSkillMarketplaceCandidatePermissions(candidate) !==
+      manifest.permissionManifestDigest ||
+    candidate.sourceEvidenceRefs.some(
+      ({ digest }) => !manifest.lineage.includes(digest),
+    )
+  )
+    throw new Error(
+      "marketplace candidate provenance, execution or permissions differ from the signed manifest",
+    );
+}
+function candidateInput(candidate) {
+  return Object.fromEntries(
+    [
+      "tenantId",
+      "skillName",
+      "content",
+      "dependencyLock",
+      "runtimeManifest",
+      "targetMatrix",
+      "sourceEvidenceRefs",
+      "derivationMode",
+      "wikiRevision",
+      "proposerModel",
+      "parentDigest",
+      "requestedCapabilities",
+    ].map((key) => [key, candidate[key]]),
+  );
+}
+export function isGovernedSkillMarketplaceCandidateInstaller(value) {
+  return INSTALLERS.has(value);
+}
+/** Owns an actual candidate-only registry; never accepts a caller-supplied write acknowledgement. */
+export function createGovernedSkillMarketplaceCandidateInstaller({
+  tenantId,
+  registryOptions,
+  artifacts,
+} = {}) {
+  const resolve = artifacts?.resolve;
+  if (typeof resolve !== "function")
+    throw new TypeError("marketplace artifact resolver is required");
+  if (
+    !registryOptions ||
+    typeof registryOptions.rootDir !== "string" ||
+    !isAbsolute(registryOptions.rootDir) ||
+    (registryOptions.tenantId !== undefined &&
+      registryOptions.tenantId !== tenantId)
+  )
+    throw new TypeError(
+      "marketplace candidate registry requires an explicit same-tenant root",
+    );
+  const authority = registryOptions.targetMatrixAdmissionAuthority;
+  if (!authority || typeof authority.resolve !== "function")
+    throw new TypeError(
+      "marketplace candidate admission authority is required",
+    );
+  const admissionResolve = authority.resolve;
+  const options = Object.freeze({
+    ...registryOptions,
+    tenantId,
+    targetMatrixAdmissionAuthority: Object.freeze({
+      ...authority,
+      resolve: (...args) => Reflect.apply(admissionResolve, authority, args),
+    }),
+  });
+  // Opening the registry validates every stored artifact. Defer that operation
+  // so a fresh CLI process can still revoke a corrupted candidate using Ledger
+  // authority alone. Materialize/read never fall back to an unverified store.
+  let registry = null;
+  const open = () => (registry ??= new SkillCandidateRegistry(options));
+  const read = (candidateId) => open().read(candidateId);
+  const create = (input) => open().create(input);
+  const verifyStored = (binding) => {
+    const candidate = read(binding.candidateId);
+    if (
+      candidate.tenantId !== tenantId ||
+      candidate.skillName !== binding.skillName ||
+      [
+        "contentDigest",
+        "dependencyLockDigest",
+        "runtimeManifestDigest",
+        "targetMatrixRoot",
+      ].some((key) => candidate[key] !== binding[key]) ||
+      hash(serializeGovernedSkillMarketplaceCandidatePackage(candidate)) !==
+        binding.adaptedOutputDigest ||
+      digestGovernedSkillMarketplaceCandidatePermissions(candidate) !==
+        binding.permissionManifestDigest
+    )
+      throw new Error(
+        "marketplace stored candidate does not match its durable binding",
+      );
+    return binding;
+  };
+  const installer = Object.freeze({
+    tenantId,
+    async materialize(inspected) {
+      const { manifest, adapted, target } = inspected;
+      if (manifest.tenantId !== tenantId)
+        throw new Error("marketplace candidate tenant mismatch");
+      const request = Object.freeze({
+        tenantId,
+        skillName: manifest.skillName,
+        version: manifest.version,
+        packageDigest: manifest.packageDigest,
+        adaptedOutputDigest: adapted.outputDigest,
+        sbomDigest: manifest.sbomDigest,
+      });
+      const resolved = await Reflect.apply(resolve, artifacts, [request]);
+      const sourceBytes = bytes(
+        resolved?.packageBytes,
+        request.packageDigest,
+        "source package",
+      );
+      const adaptedBytes = bytes(
+        resolved?.adaptedBytes,
+        request.adaptedOutputDigest,
+        "adapted package",
+      );
+      bytes(resolved?.sbomBytes, request.sbomDigest, "SBOM");
+      const source = parsePackage(sourceBytes);
+      const candidate = parsePackage(adaptedBytes);
+      matchManifest(source, manifest);
+      matchManifest(candidate, manifest);
+      const runtime = candidate.runtimeManifest.runtimes.find(
+        ({ runtimeId }) => runtimeId === target.tool,
+      );
+      if (
+        !candidate.targetRuntimes.includes(target.tool) ||
+        runtime?.descriptor.platform !== target.os ||
+        runtime.descriptor.runtime !== target.runtime
+      )
+        throw new Error(
+          "marketplace adapted candidate runtime does not match the evaluated target",
+        );
+      const core = {
+        schema: GOVERNED_SKILL_MARKETPLACE_CANDIDATE_BINDING_SCHEMA,
+        tenantId,
+        skillName: manifest.skillName,
+        manifestDigest: manifest.manifestDigest,
+        ...request,
+        candidateId: candidate.candidateId,
+        contentDigest: candidate.contentDigest,
+        dependencyLockDigest: candidate.dependencyLockDigest,
+        runtimeManifestDigest: candidate.runtimeManifestDigest,
+        targetMatrixRoot: candidate.targetMatrixRoot,
+        permissionManifestDigest: manifest.permissionManifestDigest,
+      };
+      delete core.version;
+      const binding = Object.freeze({
+        ...core,
+        bindingDigest: bindingDigest(core),
+      });
+      const result = create(candidateInput(candidate));
+      if (result.candidate.candidateId !== candidate.candidateId)
+        throw new Error(
+          "marketplace candidate registry returned a different candidate",
+        );
+      return verifyStored(binding);
+    },
+    verify(state) {
+      if (state?.tenantId !== tenantId)
+        throw new Error("marketplace candidate tenant mismatch");
+      return verifyStored(
+        verifyGovernedSkillMarketplaceCandidateBinding(
+          state.candidateBinding,
+          state,
+        ),
+      );
+    },
+  });
+  INSTALLERS.add(installer);
+  return installer;
+}