agentcert 0.2.2 → 0.2.4

package/README.md

@@ -42,8 +42,15 @@ npx agentcert push --evidence .agentcert/latest/agentcert-evidence.json
 ```
 
 Add `--push` to `agentcert run` to run locally and upload the resulting bundle
-in one command. Project API keys can create runs, record events, and upload
-evidence, but cannot approve their own runtime actions.
+in one command. By default, both commands also upload local files referenced by
+the bundle. Reads are confined to `--artifact-root` (the current directory by
+default), path and symlink escapes are rejected, and uploads are capped at 25
+files, 10 MiB per file, and 50 MiB total. Skipped references are reported in
+the CLI and hosted run timeline. Companion uploads are restricted to
+PNG/JPEG/WebP, JSON/JSONL, HTML, PDF, and ZIP; other extensions are skipped
+before they are read. Pass `--no-artifacts` to upload only the JSON bundle.
+Project API keys can create runs, record events, and upload evidence, but
+cannot approve their own runtime actions.
 
 Review/export helpers:
 

package/dist/artifact-validation.js

@@ -4,21 +4,24 @@ export async function validateEvidenceArtifacts(input, artifactRoot) {
     if (!input || typeof input !== "object" || Array.isArray(input)) {
         return { checked: 0, missing: [] };
     }
-    const paths = collectArtifactPaths(input, artifactRoot);
-    const uniquePaths = dedupeArtifactPathEntries(paths).filter((entry) => !looksLikeUrl(entry.path));
+    const uniquePaths = collectEvidenceArtifactPaths(input, artifactRoot)
+        .filter((entry) => !isRemoteArtifactPath(entry.sourcePath));
     const missing = [];
     for (const entry of uniquePaths) {
-        const fullPath = isAbsolute(entry.path) ? entry.path : resolve(entry.root, entry.path);
+        const fullPath = isAbsolute(entry.sourcePath) ? entry.sourcePath : resolve(entry.root, entry.sourcePath);
         try {
             await access(fullPath);
         }
         catch {
-            missing.push(entry.path);
+            missing.push(entry.sourcePath);
         }
     }
     return { checked: uniquePaths.length, missing };
 }
-function collectArtifactPaths(bundle, artifactRoot) {
+export function collectEvidenceArtifactPaths(input, artifactRoot) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return [];
+    const bundle = input;
     const paths = [];
     const productRoots = productArtifactRoots(bundle, artifactRoot);
     collectStringValues(bundle.artifacts, paths, artifactRoot);
@@ -27,20 +30,25 @@ function collectArtifactPaths(bundle, artifactRoot) {
         if (result && typeof result === "object" && !Array.isArray(result)) {
             const resultRecord = result;
             collectStringValues(resultRecord.artifacts, paths, artifactRoot);
+            const product = typeof resultRecord.product === "string" ? resultRecord.product : undefined;
+            collectEvidencePaths(resultRecord.evidence, paths, product ? (productRoots.get(product) ?? artifactRoot) : artifactRoot);
         }
     }
-    const evidence = Array.isArray(bundle.evidence) ? bundle.evidence : [];
+    collectEvidencePaths(bundle.evidence, paths, artifactRoot, productRoots);
+    return dedupeArtifactPathEntries(paths);
+}
+function collectEvidencePaths(input, paths, root, productRoots) {
+    const evidence = Array.isArray(input) ? input : [];
     for (const item of evidence) {
         if (item && typeof item === "object" && !Array.isArray(item)) {
             const itemRecord = item;
             const artifactPath = itemRecord.artifactPath;
             if (typeof artifactPath === "string" && artifactPath.length > 0) {
                 const source = typeof itemRecord.source === "string" ? itemRecord.source : undefined;
-                paths.push({ path: artifactPath, root: source ? (productRoots.get(source) ?? artifactRoot) : artifactRoot });
+                paths.push({ sourcePath: artifactPath, root: source && productRoots ? (productRoots.get(source) ?? root) : root });
             }
         }
     }
-    return paths;
 }
 function productArtifactRoots(bundle, artifactRoot) {
     const roots = new Map();
@@ -71,7 +79,7 @@ function collectStringValues(input, paths, root) {
     }
     for (const value of Object.values(input)) {
         if (typeof value === "string" && value.length > 0) {
-            paths.push({ path: value, root });
+            paths.push({ sourcePath: value, root });
         }
     }
 }
@@ -79,7 +87,7 @@ function dedupeArtifactPathEntries(entries) {
     const seen = new Set();
     const deduped = [];
     for (const entry of entries) {
-        const key = `${entry.root}\0${entry.path}`;
+        const key = `${entry.root}\0${entry.sourcePath}`;
         if (seen.has(key))
             continue;
         seen.add(key);
@@ -87,6 +95,6 @@ function dedupeArtifactPathEntries(entries) {
     }
     return deduped;
 }
-function looksLikeUrl(value) {
+export function isRemoteArtifactPath(value) {
     return /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
 }

package/dist/cli.js

@@ -5,6 +5,7 @@ import { createInterface } from "node:readline/promises";
 import { validateEvidenceArtifacts } from "./artifact-validation.js";
 import { renderAgentCertBadge } from "./badge.js";
 import { buildEvidenceBundle } from "./bundle.js";
+import { collectCompanionArtifacts, MAX_REPORTED_COMPANION_ARTIFACT_SKIPS } from "./companion-artifacts.js";
 import { recordsFromAgentCertResult, evaluateFailureClassifier, renderCorpusSummary, summarizeCorpus, writeReviewedFailureDataset, } from "./corpus.js";
 import { openCorpusStore, parseCorpusStoreKind } from "./corpus-store.js";
 import { pushEvidenceToControlPlane, verifyControlPlaneConnection } from "./control-plane.js";
@@ -521,7 +522,7 @@ else {
   agentcert monitor build --corpus .agentcert/corpus/corpus.jsonl --out .agentcert/latest/monitor.json --subject my-agent
   agentcert monitor build --store sqlite --sqlite .agentcert/corpus/agentcert.sqlite --out .agentcert/latest/monitor.json --subject my-agent
   agentcert run --profile public-demo
-  agentcert push --evidence .agentcert/latest/agentcert-evidence.json --server https://agentcert.example.com --project <project-id>
+  agentcert push --evidence .agentcert/latest/agentcert-evidence.json --server https://agentcert.example.com --project <project-id> [--artifact-root .] [--no-artifacts]
   agentcert run --tripwire .tripwire/latest/tripwire-result.json --push
   agentcert run --mcpbench .mcpbench/latest/results.json --tripwire .tripwire/latest/tripwire-result.json --onegent .onegent/procurement/audit-packet.json --out .agentcert/latest --corpus .agentcert/corpus/corpus.jsonl --monitor-out .agentcert/latest/monitor.json --reviewed-dataset-out .agentcert/latest/reviewed-failure-dataset.jsonl
   agentcert release-gate --config agentcert.config.json --strict
@@ -551,6 +552,9 @@ async function pushHostedEvidence(bundle, bytes, fileName) {
         projectId: readFlag("--project"),
         apiKey: readFlag("--api-key"),
     });
+    const companions = readBoolFlag("--no-artifacts")
+        ? undefined
+        : await collectCompanionArtifacts(bundle, resolve(readFlag("--artifact-root") ?? process.cwd()));
     const result = await pushEvidenceToControlPlane({
         baseUrl: connection.server,
         projectId: connection.projectId,
@@ -559,8 +563,19 @@ async function pushHostedEvidence(bundle, bytes, fileName) {
         evidenceBytes: bytes,
         fileName,
         externalId: readFlag("--external-id"),
+        companionArtifacts: companions?.artifacts,
+        skippedCompanionArtifacts: companions?.skipped,
     });
     process.stdout.write(`Hosted run: ${result.runId}\nHosted evidence: ${result.evidenceId}\n`);
+    if (companions) {
+        process.stdout.write(`Hosted companion artifacts: ${result.artifactsUploaded} uploaded, ${result.artifactsSkipped} skipped, ${result.artifactBytesUploaded} bytes.\n`);
+        for (const skipped of companions.skipped.slice(0, MAX_REPORTED_COMPANION_ARTIFACT_SKIPS)) {
+            process.stderr.write(`Skipped companion artifact ${skipped.sourcePath}: ${skipped.reason}${skipped.detail ? ` (${skipped.detail})` : ""}.\n`);
+        }
+        if (companions.skipped.length > MAX_REPORTED_COMPANION_ARTIFACT_SKIPS) {
+            process.stderr.write(`${companions.skipped.length - MAX_REPORTED_COMPANION_ARTIFACT_SKIPS} additional skipped artifacts omitted.\n`);
+        }
+    }
 }
 async function promptValue(label) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {

package/dist/companion-artifacts.js

@@ -0,0 +1,170 @@
+import { lstat, open, realpath, stat } from "node:fs/promises";
+import { basename, extname, isAbsolute, relative, resolve, sep } from "node:path";
+import { collectEvidenceArtifactPaths, isRemoteArtifactPath, } from "./artifact-validation.js";
+export const DEFAULT_COMPANION_ARTIFACT_LIMITS = {
+    maxFiles: 25,
+    maxFileBytes: 10 * 1024 * 1024,
+    maxTotalBytes: 50 * 1024 * 1024,
+};
+export const MAX_REPORTED_COMPANION_ARTIFACT_SKIPS = 50;
+export async function collectCompanionArtifacts(bundle, artifactRoot, limits = DEFAULT_COMPANION_ARTIFACT_LIMITS) {
+    validateLimits(limits);
+    const root = await realpath(resolve(artifactRoot));
+    const artifacts = [];
+    const skipped = [];
+    const uploadedRealPaths = new Set();
+    let totalBytes = 0;
+    for (const entry of collectEvidenceArtifactPaths(bundle, root)) {
+        if (isRemoteArtifactPath(entry.sourcePath)) {
+            skipped.push(skip(entry, "remote_url"));
+            continue;
+        }
+        const descriptor = describeArtifact(entry.sourcePath);
+        if (!descriptor) {
+            skipped.push(skip(entry, "unsupported_type", "accepted formats: PNG, JPEG, WebP, JSON, JSONL, HTML, PDF, ZIP"));
+            continue;
+        }
+        if (artifacts.length >= limits.maxFiles) {
+            skipped.push(skip(entry, "file_limit", `maximum ${limits.maxFiles} files`));
+            continue;
+        }
+        const candidate = isAbsolute(entry.sourcePath)
+            ? resolve(entry.sourcePath)
+            : resolve(entry.root, entry.sourcePath);
+        if (!isWithinRoot(root, candidate)) {
+            skipped.push(skip(entry, "outside_artifact_root"));
+            continue;
+        }
+        let candidateInfo;
+        try {
+            candidateInfo = await lstat(candidate);
+        }
+        catch (error) {
+            skipped.push(skip(entry, errorCode(error) === "ENOENT" ? "missing" : "unreadable", errorMessage(error)));
+            continue;
+        }
+        if (candidateInfo.isSymbolicLink()) {
+            skipped.push(skip(entry, "symlink"));
+            continue;
+        }
+        let resolvedPath;
+        try {
+            resolvedPath = await realpath(candidate);
+        }
+        catch (error) {
+            skipped.push(skip(entry, errorCode(error) === "ENOENT" ? "missing" : "unreadable", errorMessage(error)));
+            continue;
+        }
+        if (!isWithinRoot(root, resolvedPath)) {
+            skipped.push(skip(entry, "outside_artifact_root"));
+            continue;
+        }
+        if (uploadedRealPaths.has(resolvedPath))
+            continue;
+        let fileInfo;
+        try {
+            fileInfo = await stat(resolvedPath);
+        }
+        catch (error) {
+            skipped.push(skip(entry, errorCode(error) === "ENOENT" ? "missing" : "unreadable", errorMessage(error)));
+            continue;
+        }
+        if (!fileInfo.isFile()) {
+            skipped.push(skip(entry, "not_file"));
+            continue;
+        }
+        if (fileInfo.size > limits.maxFileBytes) {
+            skipped.push(skip(entry, "file_too_large", `${fileInfo.size} bytes exceeds ${limits.maxFileBytes}`));
+            continue;
+        }
+        if (totalBytes + fileInfo.size > limits.maxTotalBytes) {
+            skipped.push(skip(entry, "total_size_limit", `maximum ${limits.maxTotalBytes} bytes`));
+            continue;
+        }
+        const remainingBytes = limits.maxTotalBytes - totalBytes;
+        let readResult;
+        try {
+            readResult = await readBounded(resolvedPath, Math.min(limits.maxFileBytes, remainingBytes));
+        }
+        catch (error) {
+            skipped.push(skip(entry, "unreadable", errorMessage(error)));
+            continue;
+        }
+        if (readResult.exceeded) {
+            const reason = remainingBytes < limits.maxFileBytes ? "total_size_limit" : "file_too_large";
+            skipped.push(skip(entry, reason));
+            continue;
+        }
+        artifacts.push({
+            sourcePath: normalizeSourcePath(entry.sourcePath),
+            fileName: basename(resolvedPath),
+            kind: descriptor.kind,
+            contentType: descriptor.contentType,
+            bytes: readResult.bytes,
+        });
+        uploadedRealPaths.add(resolvedPath);
+        totalBytes += readResult.bytes.byteLength;
+    }
+    return { artifacts, skipped, totalBytes, limits: { ...limits } };
+}
+function validateLimits(limits) {
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value <= 0)
+            throw new Error(`${name} must be a positive integer.`);
+    }
+}
+function isWithinRoot(root, candidate) {
+    const pathFromRoot = relative(root, candidate);
+    return pathFromRoot === "" || (!pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== ".." && !isAbsolute(pathFromRoot));
+}
+async function readBounded(path, maxBytes) {
+    const handle = await open(path, "r");
+    const chunks = [];
+    let total = 0;
+    try {
+        while (total <= maxBytes) {
+            const capacity = Math.min(64 * 1024, maxBytes + 1 - total);
+            const chunk = Buffer.allocUnsafe(capacity);
+            const { bytesRead } = await handle.read(chunk, 0, capacity, null);
+            if (bytesRead === 0)
+                return { bytes: Buffer.concat(chunks, total), exceeded: false };
+            chunks.push(chunk.subarray(0, bytesRead));
+            total += bytesRead;
+        }
+        return { bytes: new Uint8Array(), exceeded: true };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function describeArtifact(path) {
+    const lower = path.toLowerCase();
+    const extension = extname(lower);
+    if ([".png", ".jpg", ".jpeg", ".webp"].includes(extension)) {
+        const imageType = extension === ".jpg" ? "jpeg" : extension.slice(1);
+        return { kind: "screenshot", contentType: `image/${imageType}` };
+    }
+    if (extension === ".zip")
+        return { kind: "trace", contentType: "application/zip" };
+    if ([".html", ".htm"].includes(extension))
+        return { kind: "dom", contentType: "text/html; charset=utf-8" };
+    if (extension === ".json")
+        return { kind: lower.includes("trace") ? "trace" : lower.includes("dom") ? "dom" : "json", contentType: "application/json" };
+    if (extension === ".jsonl")
+        return { kind: lower.includes("trace") ? "trace" : "json", contentType: "application/x-ndjson" };
+    if (extension === ".pdf")
+        return { kind: "report", contentType: "application/pdf" };
+    return undefined;
+}
+function normalizeSourcePath(path) {
+    return path.replace(/\\/g, "/").slice(0, 1024);
+}
+function skip(entry, reason, detail) {
+    return { sourcePath: normalizeSourcePath(entry.sourcePath), reason, ...(detail ? { detail } : {}) };
+}
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/control-plane.js

@@ -1,3 +1,4 @@
+import { MAX_REPORTED_COMPANION_ARTIFACT_SKIPS, } from "./companion-artifacts.js";
 export class ControlPlaneRequestError extends Error {
     status;
     constructor(message, status) {
@@ -85,6 +86,47 @@ export async function pushEvidenceToControlPlane(options) {
         headers: { ...headers, "content-type": "application/json" },
         body: new Uint8Array(options.evidenceBytes).buffer,
     });
+    const companionArtifacts = options.companionArtifacts ?? [];
+    const skippedArtifacts = options.skippedCompanionArtifacts ?? [];
+    let artifactBytesUploaded = 0;
+    for (const artifact of companionArtifacts) {
+        const artifactQuery = new URLSearchParams({
+            fileName: artifact.fileName,
+            kind: artifact.kind,
+            schemaVersion: options.bundle.schemaVersion,
+            runId: run.id,
+            sourcePath: artifact.sourcePath,
+        });
+        await requestJson(request, `${projectUrl}/evidence?${artifactQuery}`, {
+            method: "POST",
+            headers: { ...headers, "content-type": artifact.contentType },
+            body: new Uint8Array(artifact.bytes).buffer,
+        });
+        artifactBytesUploaded += artifact.bytes.byteLength;
+    }
+    if (companionArtifacts.length > 0 || skippedArtifacts.length > 0) {
+        await requestJson(request, `${projectUrl}/runs/${encodeURIComponent(run.id)}/events`, {
+            method: "POST",
+            headers: { ...headers, "content-type": "application/json" },
+            body: JSON.stringify({
+                events: [{
+                        sequence: 1,
+                        type: "agentcert.companion_artifacts.processed",
+                        actor: "agentcert-cli",
+                        occurredAt: options.bundle.generatedAt,
+                        payload: {
+                            uploadedCount: companionArtifacts.length,
+                            skippedCount: skippedArtifacts.length,
+                            uploadedBytes: artifactBytesUploaded,
+                            skipped: skippedArtifacts
+                                .slice(0, MAX_REPORTED_COMPANION_ARTIFACT_SKIPS)
+                                .map(({ sourcePath, reason }) => ({ sourcePath, reason })),
+                            skippedDetailsTruncated: skippedArtifacts.length > MAX_REPORTED_COMPANION_ARTIFACT_SKIPS,
+                        },
+                    }],
+            }),
+        });
+    }
     const firstDivergence = options.bundle.evidence.find((item) => item.severity === "critical" || item.severity === "high")?.message;
     await requestJson(request, `${projectUrl}/runs/${encodeURIComponent(run.id)}/complete`, {
         method: "POST",
@@ -98,10 +140,20 @@ export async function pushEvidenceToControlPlane(options) {
             metadata: {
                 evidenceId: evidence.id,
                 evidenceSchemaVersion: options.bundle.schemaVersion,
+                companionArtifactsUploaded: companionArtifacts.length,
+                companionArtifactsSkipped: skippedArtifacts.length,
+                companionArtifactBytesUploaded: artifactBytesUploaded,
             },
         }),
     });
-    return { runId: run.id, evidenceId: evidence.id, externalId };
+    return {
+        runId: run.id,
+        evidenceId: evidence.id,
+        externalId,
+        artifactsUploaded: companionArtifacts.length,
+        artifactsSkipped: skippedArtifacts.length,
+        artifactBytesUploaded,
+    };
 }
 function hostedRunKind(bundle) {
     const products = new Set(bundle.summary.products);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcert",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Assurance release gates, runtime evidence, and regression CI for AI agents.",
   "type": "module",
   "license": "Apache-2.0",