agentcert 0.3.0 → 0.5.0

package/README.md

@@ -82,6 +82,35 @@ certifications return a non-zero exit status. The generated template is
 synthetic and network-denied; it must not contain production credentials or
 connect to live systems.
 
+Run one bounded read against an existing Stripe sandbox PaymentIntent:
+
+```bash
+STRIPE_RESTRICTED_TEST_KEY="rk_test_..." npx agentcert sandbox stripe-readonly --payment-intent pi_...
+```
+
+Add `--push` to retain the redacted report in AgentCert Hosted. The command
+allows only `https://api.stripe.com`, `GET`, and allowlisted PaymentIntent
+routes, with a 5-second timeout and 10-request-per-minute process-local cap.
+The Stripe key is environment-only and is never written to output or evidence.
+See the [Bounded Vendor Sandbox Egress guide](https://github.com/Kakarottoooo/agentcert/blob/main/docs/bounded-vendor-sandbox-egress.md).
+
+Release maintainers can run the protected, manual
+`Real Stripe sandbox acceptance` GitHub workflow. It performs the bounded read,
+independently scans the generated report before upload, validates it again at
+the CLI boundary, uploads the v0.4 evidence, and compares it with prior
+protected runs. See the [real vendor acceptance guide](https://github.com/Kakarottoooo/agentcert/blob/main/docs/real-vendor-acceptance.md).
+
+The workflow's upload step is also available as a narrow command for an
+already-generated report:
+
+```bash
+npx agentcert sandbox upload-report --report .agentcert/vendor-sandbox/current-report.json --external-id vendor-acceptance:stripe:<run>:<attempt>
+```
+
+This command accepts only AgentCert sandbox conformance and vendor-egress
+contracts and rejects reports containing credential-shaped values or forbidden
+sensitive fields.
+
 Review/export helpers:
 
 ```bash

package/dist/sandbox.js

@@ -1,9 +1,10 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { resolveConnection } from "./credentials.js";
 const DEFAULT_ADAPTER_PATH = "agentcert.sandbox.mjs";
 const DEFAULT_REPORT_PATH = ".agentcert/sandbox/sandbox-adapter-conformance.json";
+const DEFAULT_STRIPE_REPORT_PATH = ".agentcert/sandbox/stripe-readonly-report.json";
 export async function runSandboxCommand(args) {
     const action = args[0] ?? "help";
     if (action === "help" || args.includes("--help") || args.includes("-h")) {
@@ -16,6 +17,10 @@ export async function runSandboxCommand(args) {
         return certifySandboxAdapter(args.slice(1));
     if (action === "push")
         return pushSandboxCertification(args.slice(1));
+    if (action === "stripe-readonly")
+        return runStripeSandboxReadOnly(args.slice(1));
+    if (action === "upload-report")
+        return uploadSandboxReport(args.slice(1));
     throw new Error(`Unknown sandbox command ${JSON.stringify(action)}. Run \`npx agentcert sandbox --help\`.`);
 }
 export async function initializeSandboxAdapter(args) {
@@ -62,6 +67,97 @@ export async function pushSandboxCertification(args, runtimeOverride) {
     process.stdout.write(`Hosted evidence: ${String(uploaded.evidence.id ?? "created")}\n`);
     return certified;
 }
+export async function runStripeSandboxReadOnly(args, runtimeOverride) {
+    if (args.includes("--stripe-key") || args.includes("--restricted-key")) {
+        throw new Error("Stripe credentials are accepted only through STRIPE_RESTRICTED_TEST_KEY, never a CLI flag.");
+    }
+    const paymentIntentId = flag(args, "--payment-intent");
+    if (!paymentIntentId)
+        throw new Error("Stripe sandbox read requires --payment-intent <pi_...>.");
+    const restrictedApiKey = process.env.STRIPE_RESTRICTED_TEST_KEY?.trim();
+    if (!restrictedApiKey) {
+        throw new Error("Set STRIPE_RESTRICTED_TEST_KEY to a read-only Stripe rk_test_ restricted key.");
+    }
+    const runtime = runtimeOverride ?? await loadSandboxRuntime();
+    if (!runtime.runStripeSandboxReadOnlyCertification) {
+        throw new Error("AgentCert Stripe sandbox runtime is missing. Reinstall the agentcert package and retry.");
+    }
+    const report = await runtime.runStripeSandboxReadOnlyCertification({ restrictedApiKey, paymentIntentId });
+    const reportPath = resolve(flag(args, "--out") ?? DEFAULT_STRIPE_REPORT_PATH);
+    await mkdir(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    renderVendorReadResult(report, reportPath);
+    if (args.includes("--push")) {
+        const connection = await resolveConnection({
+            name: flag(args, "--connection"),
+            server: flag(args, "--server"),
+            projectId: flag(args, "--project"),
+            apiKey: flag(args, "--api-key"),
+        });
+        const uploaded = await runtime.uploadSandboxCertificationReport(report, {
+            baseUrl: connection.server,
+            projectId: connection.projectId,
+            apiKey: connection.apiKey,
+            externalId: flag(args, "--external-id"),
+        });
+        process.stdout.write(`Hosted sandbox run: ${String(uploaded.run.id ?? "created")}\n`);
+        process.stdout.write(`Hosted evidence: ${String(uploaded.evidence.id ?? "created")}\n`);
+    }
+    return { exitCode: report.verdict.passed ? 0 : 1, reportPath, report };
+}
+export async function uploadSandboxReport(args, runtimeOverride) {
+    const requestedPath = flag(args, "--report");
+    if (!requestedPath)
+        throw new Error("Sandbox report upload requires --report <report.json>.");
+    const reportPath = resolve(requestedPath);
+    const report = parseUploadableSandboxReport(await readFile(reportPath, "utf8"));
+    const runtime = runtimeOverride ?? await loadSandboxRuntime();
+    const connection = await resolveConnection({
+        name: flag(args, "--connection"),
+        server: flag(args, "--server"),
+        projectId: flag(args, "--project"),
+        apiKey: flag(args, "--api-key"),
+    });
+    const uploaded = await runtime.uploadSandboxCertificationReport(report, {
+        baseUrl: connection.server,
+        projectId: connection.projectId,
+        apiKey: connection.apiKey,
+        externalId: flag(args, "--external-id"),
+    });
+    process.stdout.write(`Uploaded validated sandbox report: ${reportPath}\n`);
+    process.stdout.write(`Hosted sandbox run: ${String(uploaded.run.id ?? "created")}\n`);
+    process.stdout.write(`Hosted evidence: ${String(uploaded.evidence.id ?? "created")}\n`);
+    return { exitCode: report.verdict.passed ? 0 : 1, reportPath, report };
+}
+export function parseUploadableSandboxReport(rawText) {
+    let value;
+    try {
+        value = JSON.parse(rawText);
+    }
+    catch {
+        throw new Error("Sandbox report is not valid JSON.");
+    }
+    if (!isRecord(value))
+        throw new Error("Sandbox report must be a JSON object.");
+    const supported = (value.kind === "agentcert.sandbox_adapter_conformance"
+        && value.schemaVersion === "agentcert.sandbox_adapter_conformance.v0.2")
+        || (value.kind === "agentcert.sandbox_vendor_egress"
+            && value.schemaVersion === "agentcert.sandbox_vendor_egress.v0.4");
+    if (!supported)
+        throw new Error("Sandbox report kind or schema version is not supported for upload.");
+    if (typeof value.implementation !== "string" || !value.implementation.trim()
+        || typeof value.generatedAt !== "string" || !Number.isFinite(Date.parse(value.generatedAt))
+        || !isRecord(value.verdict) || typeof value.verdict.passed !== "boolean"
+        || typeof value.verdict.score !== "number" || value.verdict.score < 0 || value.verdict.score > 100
+        || !Array.isArray(value.checks)) {
+        throw new Error("Sandbox report is missing required conformance fields.");
+    }
+    const findings = sensitiveReportFindings(value, rawText);
+    if (findings.length > 0) {
+        throw new Error(`Sandbox report contains forbidden credential material: ${findings.join(", ")}.`);
+    }
+    return value;
+}
 export async function loadSandboxAdapter(adapterPath) {
     let module;
     try {
@@ -96,16 +192,37 @@ Runs the deterministic sandbox adapter conformance suite locally.
 
 Runs certification, writes the local report, and uploads it through the saved AgentCert connection.
 Use \`agentcert connect\` first, or pass --server, --project, and --api-key.
+`;
+    if (action === "stripe-readonly")
+        return `Usage:
+  STRIPE_RESTRICTED_TEST_KEY=rk_test_... agentcert sandbox stripe-readonly --payment-intent pi_...
+  agentcert sandbox stripe-readonly --payment-intent pi_... --push
+
+Reads one Stripe sandbox PaymentIntent through a fixed GET/resource allowlist,
+writes a redacted evidence report, and optionally uploads it to AgentCert Hosted.
+The Stripe key is read only from STRIPE_RESTRICTED_TEST_KEY.
+`;
+    if (action === "upload-report")
+        return `Usage:
+  agentcert sandbox upload-report --report .agentcert/vendor-sandbox/current-report.json --external-id <id>
+
+Validates a recognized AgentCert sandbox report, rejects credential material,
+and uploads it through the saved AgentCert connection. This command never
+executes a vendor request.
 `;
     return `Usage:
   agentcert sandbox init [--adapter agentcert.sandbox.mjs]
   agentcert sandbox certify --adapter ./my-sandbox-adapter.js
   agentcert sandbox push --adapter ./my-sandbox-adapter.js
+  agentcert sandbox stripe-readonly --payment-intent pi_... [--push]
+  agentcert sandbox upload-report --report <report.json>
 
 Commands:
   init      Write one dependency-free adapter template
   certify   Run deterministic local conformance checks
   push      Certify and upload the report to AgentCert Hosted
+  stripe-readonly  Run one bounded Stripe sandbox read and write evidence
+  upload-report    Validate and upload an existing sandbox report
 
 Common options:
   --adapter <path>        Adapter module (default: agentcert.sandbox.mjs)
@@ -117,9 +234,14 @@ Common options:
 async function loadSandboxRuntime() {
     const adapterKitUrl = new URL("./vendor/onegent-runtime/sandbox-adapter-kit.js", import.meta.url);
     const hostedUrl = new URL("./vendor/onegent-runtime/sandbox-hosted.js", import.meta.url);
+    const stripeUrl = new URL("./vendor/onegent-runtime/stripe-test-readonly.js", import.meta.url);
     try {
-        const [adapterKit, hosted] = await Promise.all([import(adapterKitUrl.href), import(hostedUrl.href)]);
-        return { ...adapterKit, ...hosted };
+        const [adapterKit, hosted, stripe] = await Promise.all([
+            import(adapterKitUrl.href),
+            import(hostedUrl.href),
+            import(stripeUrl.href),
+        ]);
+        return { ...adapterKit, ...hosted, ...stripe };
     }
     catch (error) {
         const code = error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
@@ -142,6 +264,38 @@ function isSandboxSystem(value) {
         && ["createTenant", "deleteTenant", "resetTenant", "seedTenant", "hasTenant", "snapshotTenant", "adapterForTenant"]
             .every((method) => typeof system[method] === "function");
 }
+function sensitiveReportFindings(value, rawText) {
+    const findings = new Set();
+    const forbiddenFields = new Set(["authorization", "headers", "apikey", "restrictedapikey", "secretkey", "clientsecret", "metadata", "rawresponse", "responsebody"]);
+    const inspect = (entry) => {
+        if (Array.isArray(entry)) {
+            entry.forEach(inspect);
+            return;
+        }
+        if (!isRecord(entry))
+            return;
+        for (const [key, nested] of Object.entries(entry)) {
+            if (forbiddenFields.has(key.replace(/[^a-z]/gi, "").toLowerCase()))
+                findings.add(`field:${key}`);
+            inspect(nested);
+        }
+    };
+    inspect(value);
+    if (/\b(?:rk|sk)_(?:test|live)_[A-Za-z0-9_]{8,}\b/.test(rawText))
+        findings.add("stripe-key");
+    if (/\bac_live_[A-Za-z0-9_-]{8,}\b/.test(rawText))
+        findings.add("agentcert-key");
+    if (/\bBearer\s+\S+/i.test(rawText))
+        findings.add("authorization-value");
+    for (const secret of [process.env.STRIPE_RESTRICTED_TEST_KEY, process.env.AGENTCERT_API_KEY]) {
+        if (secret && secret.length >= 8 && rawText.includes(secret))
+            findings.add("exact-secret");
+    }
+    return [...findings].sort();
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 function flag(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] : undefined;
@@ -165,6 +319,14 @@ function renderCertificationResult(report, reportPath) {
     }
     process.stdout.write(`Report: ${reportPath}\n`);
 }
+function renderVendorReadResult(report, reportPath) {
+    process.stdout.write(`${report.verdict.passed ? "PASS" : "FAIL"} ${report.verdict.score}/100 Stripe sandbox bounded read\n`);
+    for (const check of report.checks) {
+        process.stdout.write(`- ${check.status === "passed" ? "PASS" : "FAIL"} ${check.id}: ${check.message}\n`);
+    }
+    process.stdout.write(`Requests audited: ${report.audit.length}\n`);
+    process.stdout.write(`Report: ${reportPath}\n`);
+}
 function sandboxAdapterTemplate() {
     return `// Synthetic local state only. Do not import production credentials or call live systems here.
 const tenants = new Map();

package/dist/vendor/onegent-runtime/sandbox-hosted.d.ts

@@ -1,7 +1,8 @@
 import type { SandboxAdapterConformanceReport } from "./sandbox-adapter-kit.js";
 import type { SandboxCertificationReport } from "./sandbox-harness.js";
+import type { StripeSandboxReadOnlyReport } from "./stripe-test-readonly.js";
 export declare const SANDBOX_EVIDENCE_BUNDLE_SCHEMA_VERSION: "agentcert.evidence.v0.1";
-export type HostedSandboxReport = SandboxCertificationReport | SandboxAdapterConformanceReport;
+export type HostedSandboxReport = SandboxCertificationReport | SandboxAdapterConformanceReport | StripeSandboxReadOnlyReport;
 export interface SandboxHostedUploadOptions {
     baseUrl: string;
     projectId: string;
@@ -48,7 +49,7 @@ export interface SandboxCertificationEvidenceBundle {
         artifacts: Record<string, string>;
         evidence: Array<{
             id: string;
-            kind: "sandbox_adapter_conformance" | "sandbox_certification";
+            kind: "sandbox_adapter_conformance" | "sandbox_certification" | "sandbox_vendor_egress";
             severity: "info" | "high";
             message: string;
             source: "onegent-runtime";

package/dist/vendor/onegent-runtime/sandbox-hosted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox-hosted.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/sandbox-hosted.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sandbox-hosted.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/sandbox-hosted.ts"],"names":[],"mappings":"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"}

package/dist/vendor/onegent-runtime/sandbox-hosted.js

@@ -5,7 +5,11 @@ export function createSandboxCertificationEvidenceBundle(report) {
     const runId = `sandbox-${reportDigest}`;
     const evidence = [{
             id: `${report.kind}:${reportDigest.slice(0, 16)}`,
-            kind: report.kind === "agentcert.sandbox_adapter_conformance" ? "sandbox_adapter_conformance" : "sandbox_certification",
+            kind: report.kind === "agentcert.sandbox_adapter_conformance"
+                ? "sandbox_adapter_conformance"
+                : report.kind === "agentcert.sandbox_vendor_egress"
+                    ? "sandbox_vendor_egress"
+                    : "sandbox_certification",
             severity: report.verdict.passed ? "info" : "high",
             message: `${report.kind} ${report.verdict.passed ? "passed" : "failed"} (${report.verdict.score}/100).`,
             source: "onegent-runtime",
@@ -64,6 +68,15 @@ export async function uploadSandboxCertificationReport(report, options) {
     const digest = createHash("sha256").update(bytes).digest("hex");
     const operationId = `sandbox-upload-${digest.slice(0, 32)}`;
     const externalId = options.externalId?.trim() || `${report.kind}:${report.implementation}:${report.generatedAt}`;
+    const vendorMetadata = report.kind === "agentcert.sandbox_vendor_egress"
+        ? {
+            vendor: report.vendor,
+            environment: report.environment,
+            policySha256: createHash("sha256").update(canonicalJson(report.policy)).digest("hex"),
+            requestDurationMs: report.audit.find((entry) => entry.outcome === "allowed")?.durationMs,
+            acceptanceType: externalId.startsWith("vendor-acceptance:stripe:") ? "real_vendor_sandbox" : "vendor_sandbox",
+        }
+        : {};
     const run = await jsonRequest(requestFetch, `${projectUrl}/runs`, apiKey, {
         method: "POST",
         headers: { "idempotency-key": `${operationId}:run` },
@@ -77,6 +90,7 @@ export async function uploadSandboxCertificationReport(report, options) {
                 evidenceType: report.kind,
                 implementation: report.implementation,
                 sandboxOnly: true,
+                ...vendorMetadata,
             },
         }),
     });
@@ -127,3 +141,12 @@ function required(value, name) {
         throw new Error(`Sandbox hosted upload ${name} is required.`);
     return normalized;
 }
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}

package/dist/vendor/onegent-runtime/stripe-test-readonly.d.ts

@@ -0,0 +1,79 @@
+import { type VendorSandboxRequestAudit } from "./vendor-sandbox-egress.js";
+export declare const STRIPE_TEST_API_ORIGIN: "https://api.stripe.com";
+export declare const STRIPE_SANDBOX_TIMEOUT_MS = 5000;
+export declare const STRIPE_SANDBOX_MAX_REQUESTS_PER_MINUTE = 10;
+export declare const STRIPE_PAYMENT_INTENT_RETRIEVE: "stripe.payment_intent.retrieve";
+export declare const STRIPE_PAYMENT_INTENT_LIST: "stripe.payment_intent.list";
+export interface StripePaymentIntentSnapshot {
+    id: string;
+    object: "payment_intent";
+    livemode: false;
+    amount?: number;
+    amountCapturable?: number;
+    amountReceived?: number;
+    currency?: string;
+    status?: string;
+    created?: number;
+}
+export interface StripeTestModeReadOnlyAdapter {
+    readonly name: "stripe-test-mode-readonly";
+    readonly safety: {
+        readonly mode: "sandbox";
+        readonly access: "read-only";
+        readonly vendor: "stripe";
+        readonly allowedOrigins: readonly [typeof STRIPE_TEST_API_ORIGIN];
+        readonly allowedMethods: readonly ["GET"];
+        readonly allowedResources: readonly [typeof STRIPE_PAYMENT_INTENT_RETRIEVE, typeof STRIPE_PAYMENT_INTENT_LIST];
+        readonly timeoutMs: number;
+        readonly maxRequestsPerMinute: number;
+    };
+    retrievePaymentIntent(id: string): Promise<StripePaymentIntentSnapshot>;
+    listPaymentIntents(limit?: number): Promise<StripePaymentIntentSnapshot[]>;
+    getRequestAudit(): VendorSandboxRequestAudit[];
+}
+export interface StripeTestModeReadOnlyOptions {
+    restrictedApiKey: string;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    maxRequestsPerMinute?: number;
+    now?: () => number;
+}
+export interface StripeSandboxReadOnlyCheck {
+    id: string;
+    status: "passed" | "failed";
+    message: string;
+}
+export interface StripeSandboxReadOnlyReport {
+    schemaVersion: "agentcert.sandbox_vendor_egress.v0.4";
+    kind: "agentcert.sandbox_vendor_egress";
+    implementation: "stripe-payment-intent-readonly";
+    vendor: "stripe";
+    environment: "sandbox";
+    generatedAt: string;
+    verdict: {
+        passed: boolean;
+        score: number;
+    };
+    summary: {
+        passed: number;
+        failed: number;
+        total: number;
+    };
+    checks: StripeSandboxReadOnlyCheck[];
+    policy: {
+        allowedOrigins: readonly [typeof STRIPE_TEST_API_ORIGIN];
+        allowedMethods: readonly ["GET"];
+        allowedResources: readonly [typeof STRIPE_PAYMENT_INTENT_RETRIEVE, typeof STRIPE_PAYMENT_INTENT_LIST];
+        timeoutMs: number;
+        maxRequestsPerMinute: number;
+    };
+    audit: VendorSandboxRequestAudit[];
+    observation?: StripePaymentIntentSnapshot;
+    disclaimer: string;
+}
+export interface RunStripeSandboxReadOnlyOptions extends StripeTestModeReadOnlyOptions {
+    paymentIntentId: string;
+}
+export declare function createStripeTestModeReadOnlyAdapter(options: StripeTestModeReadOnlyOptions): StripeTestModeReadOnlyAdapter;
+export declare function runStripeSandboxReadOnlyCertification(options: RunStripeSandboxReadOnlyOptions): Promise<StripeSandboxReadOnlyReport>;
+//# sourceMappingURL=stripe-test-readonly.d.ts.map

package/dist/vendor/onegent-runtime/stripe-test-readonly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripe-test-readonly.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/stripe-test-readonly.ts"],"names":[],"mappings":"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"}

package/dist/vendor/onegent-runtime/stripe-test-readonly.js

@@ -0,0 +1,163 @@
+import { createBoundedVendorSandboxEgress, VendorSandboxEgressError, } from "./vendor-sandbox-egress.js";
+export const STRIPE_TEST_API_ORIGIN = "https://api.stripe.com";
+export const STRIPE_SANDBOX_TIMEOUT_MS = 5_000;
+export const STRIPE_SANDBOX_MAX_REQUESTS_PER_MINUTE = 10;
+export const STRIPE_PAYMENT_INTENT_RETRIEVE = "stripe.payment_intent.retrieve";
+export const STRIPE_PAYMENT_INTENT_LIST = "stripe.payment_intent.list";
+const STRIPE_RESOURCES = Object.freeze([
+    Object.freeze({
+        id: STRIPE_PAYMENT_INTENT_RETRIEVE,
+        method: "GET",
+        pathPattern: /^\/v1\/payment_intents\/pi_[A-Za-z0-9]{8,128}$/,
+    }),
+    Object.freeze({
+        id: STRIPE_PAYMENT_INTENT_LIST,
+        method: "GET",
+        pathPattern: /^\/v1\/payment_intents\?limit=(?:[1-9]|10)$/,
+    }),
+]);
+export function createStripeTestModeReadOnlyAdapter(options) {
+    const apiKey = options.restrictedApiKey.trim();
+    if (!/^rk_test_[A-Za-z0-9_]{8,}$/.test(apiKey)) {
+        throw new Error("Stripe read-only reference adapter requires an rk_test_ restricted test-mode key.");
+    }
+    const timeoutMs = options.timeoutMs ?? STRIPE_SANDBOX_TIMEOUT_MS;
+    const maxRequestsPerMinute = options.maxRequestsPerMinute ?? STRIPE_SANDBOX_MAX_REQUESTS_PER_MINUTE;
+    const egress = createBoundedVendorSandboxEgress({
+        policy: {
+            vendor: "stripe",
+            allowedOrigin: STRIPE_TEST_API_ORIGIN,
+            resources: STRIPE_RESOURCES,
+            timeoutMs,
+            maxRequestsPerMinute,
+        },
+        fetch: options.fetch,
+        now: options.now,
+    });
+    const get = (resource, path) => egress.requestJson({
+        resource,
+        method: "GET",
+        path,
+        headers: {
+            authorization: `Bearer ${apiKey}`,
+            accept: "application/json",
+            "user-agent": "agentcert-onegent-runtime/stripe-sandbox-readonly-v0.4",
+        },
+    });
+    return Object.freeze({
+        name: "stripe-test-mode-readonly",
+        safety: Object.freeze({
+            mode: "sandbox",
+            access: "read-only",
+            vendor: "stripe",
+            allowedOrigins: Object.freeze([STRIPE_TEST_API_ORIGIN]),
+            allowedMethods: Object.freeze(["GET"]),
+            allowedResources: Object.freeze([STRIPE_PAYMENT_INTENT_RETRIEVE, STRIPE_PAYMENT_INTENT_LIST]),
+            timeoutMs,
+            maxRequestsPerMinute,
+        }),
+        retrievePaymentIntent: async (id) => {
+            if (!/^pi_[A-Za-z0-9]{8,128}$/.test(id))
+                throw new Error("Stripe PaymentIntent ID is invalid.");
+            return paymentIntentSnapshot(await get(STRIPE_PAYMENT_INTENT_RETRIEVE, `/v1/payment_intents/${encodeURIComponent(id)}`));
+        },
+        listPaymentIntents: async (limit = 10) => {
+            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10)
+                throw new Error("Stripe read-only list limit must be an integer from 1 to 10.");
+            const payload = await get(STRIPE_PAYMENT_INTENT_LIST, `/v1/payment_intents?limit=${limit}`);
+            if (!isRecord(payload) || payload.object !== "list" || !Array.isArray(payload.data)) {
+                throw new Error("Stripe returned an invalid PaymentIntent list response.");
+            }
+            return payload.data.map(paymentIntentSnapshot);
+        },
+        getRequestAudit: () => egress.getAuditLog(),
+    });
+}
+export async function runStripeSandboxReadOnlyCertification(options) {
+    const generatedAt = new Date((options.now ?? Date.now)()).toISOString();
+    const timeoutMs = options.timeoutMs ?? STRIPE_SANDBOX_TIMEOUT_MS;
+    const maxRequestsPerMinute = options.maxRequestsPerMinute ?? STRIPE_SANDBOX_MAX_REQUESTS_PER_MINUTE;
+    const checks = [];
+    let adapter;
+    let observation;
+    try {
+        adapter = createStripeTestModeReadOnlyAdapter(options);
+        checks.push(passed("restricted-test-key", "Credential format is restricted to Stripe rk_test_ keys and is not retained."), passed("fixed-egress-policy", "Egress is fixed to Stripe HTTPS, GET, and allowlisted PaymentIntent resources."));
+        observation = await adapter.retrievePaymentIntent(options.paymentIntentId);
+        checks.push(passed("bounded-read", "The allowlisted PaymentIntent read completed within the configured bounds."), passed("test-mode-response", "Stripe explicitly returned livemode=false."), passed("evidence-redaction", "The evidence snapshot excludes credentials, client_secret, metadata, and raw response bytes."));
+    }
+    catch (error) {
+        if (!adapter) {
+            checks.push(failed("restricted-test-key", "A valid Stripe rk_test_ restricted test-mode key was not available."), failed("fixed-egress-policy", "The request was not attempted because credential validation failed."));
+        }
+        else {
+            checks.push(failed("bounded-read", safeStripeFailure(error)));
+        }
+        checks.push(failed("test-mode-response", "No validated Stripe test-mode observation was produced."), failed("evidence-redaction", "No successful redacted observation was produced."));
+    }
+    const passedCount = checks.filter((check) => check.status === "passed").length;
+    const report = {
+        schemaVersion: "agentcert.sandbox_vendor_egress.v0.4",
+        kind: "agentcert.sandbox_vendor_egress",
+        implementation: "stripe-payment-intent-readonly",
+        vendor: "stripe",
+        environment: "sandbox",
+        generatedAt,
+        verdict: { passed: passedCount === checks.length, score: Math.round((passedCount / checks.length) * 100) },
+        summary: { passed: passedCount, failed: checks.length - passedCount, total: checks.length },
+        checks,
+        policy: {
+            allowedOrigins: [STRIPE_TEST_API_ORIGIN],
+            allowedMethods: ["GET"],
+            allowedResources: [STRIPE_PAYMENT_INTENT_RETRIEVE, STRIPE_PAYMENT_INTENT_LIST],
+            timeoutMs,
+            maxRequestsPerMinute,
+        },
+        audit: adapter?.getRequestAudit() ?? [],
+        ...(observation ? { observation } : {}),
+        disclaimer: "Stripe sandbox read-only evidence proves this bounded test-mode observation only. It does not authorize writes, attest Stripe controls, or certify production behavior.",
+    };
+    return structuredClone(report);
+}
+function paymentIntentSnapshot(value) {
+    if (!isRecord(value) || value.object !== "payment_intent" || typeof value.id !== "string") {
+        throw new Error("Stripe returned an invalid PaymentIntent response.");
+    }
+    if (value.livemode !== false)
+        throw new Error("Stripe read-only adapter refuses responses that are not explicitly test mode.");
+    return {
+        id: value.id,
+        object: "payment_intent",
+        livemode: false,
+        ...numberField(value, "amount", "amount"),
+        ...numberField(value, "amount_capturable", "amountCapturable"),
+        ...numberField(value, "amount_received", "amountReceived"),
+        ...stringField(value, "currency", "currency"),
+        ...stringField(value, "status", "status"),
+        ...numberField(value, "created", "created"),
+    };
+}
+function safeStripeFailure(error) {
+    if (error instanceof VendorSandboxEgressError)
+        return `Stripe sandbox read failed (${error.code}).`;
+    if (error instanceof Error && error.message.includes("not explicitly test mode"))
+        return "Stripe response was not explicitly test mode.";
+    if (error instanceof Error && error.message.includes("invalid PaymentIntent"))
+        return "Stripe returned an invalid PaymentIntent response.";
+    return "Stripe sandbox read failed before a validated observation was produced.";
+}
+function passed(id, message) {
+    return { id, status: "passed", message };
+}
+function failed(id, message) {
+    return { id, status: "failed", message };
+}
+function numberField(value, source, target) {
+    return typeof value[source] === "number" && Number.isFinite(value[source]) ? { [target]: value[source] } : {};
+}
+function stringField(value, source, target) {
+    return typeof value[source] === "string" ? { [target]: value[source] } : {};
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/vendor/onegent-runtime/vendor-sandbox-egress.d.ts

@@ -0,0 +1,49 @@
+export type VendorSandboxHttpMethod = "GET";
+export interface VendorSandboxResourceRule {
+    id: string;
+    method: VendorSandboxHttpMethod;
+    pathPattern: RegExp;
+}
+export interface VendorSandboxEgressPolicy {
+    vendor: string;
+    allowedOrigin: string;
+    resources: readonly VendorSandboxResourceRule[];
+    timeoutMs: number;
+    maxRequestsPerMinute: number;
+}
+export type VendorSandboxAuditOutcome = "allowed" | "denied" | "rate_limited" | "timeout" | "http_error" | "failed";
+export interface VendorSandboxRequestAudit {
+    requestId: string;
+    timestamp: string;
+    vendor: string;
+    resource: string;
+    method: VendorSandboxHttpMethod;
+    origin: string;
+    outcome: VendorSandboxAuditOutcome;
+    durationMs: number;
+    status?: number;
+    errorCode?: VendorSandboxEgressErrorCode;
+}
+export type VendorSandboxEgressErrorCode = "ORIGIN_DENIED" | "METHOD_DENIED" | "RESOURCE_DENIED" | "RATE_LIMITED" | "TIMEOUT" | "HTTP_ERROR" | "REQUEST_FAILED";
+export declare class VendorSandboxEgressError extends Error {
+    readonly code: VendorSandboxEgressErrorCode;
+    readonly status?: number | undefined;
+    constructor(code: VendorSandboxEgressErrorCode, message: string, status?: number | undefined);
+}
+export interface VendorSandboxEgressRequest {
+    resource: string;
+    method: VendorSandboxHttpMethod;
+    path: string;
+    headers?: HeadersInit;
+}
+export interface BoundedVendorSandboxEgress {
+    requestJson(request: VendorSandboxEgressRequest): Promise<unknown>;
+    getAuditLog(): VendorSandboxRequestAudit[];
+}
+export interface BoundedVendorSandboxEgressOptions {
+    policy: VendorSandboxEgressPolicy;
+    fetch?: typeof fetch;
+    now?: () => number;
+}
+export declare function createBoundedVendorSandboxEgress(options: BoundedVendorSandboxEgressOptions): BoundedVendorSandboxEgress;
+//# sourceMappingURL=vendor-sandbox-egress.d.ts.map

package/dist/vendor/onegent-runtime/vendor-sandbox-egress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-sandbox-egress.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/vendor-sandbox-egress.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,KAAK,CAAC;AAE5C,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,uBAAuB,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,MAAM,yBAAyB,GACjC,SAAS,GACT,QAAQ,GACR,cAAc,GACd,SAAS,GACT,YAAY,GACZ,QAAQ,CAAC;AAEb,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,yBAAyB,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,4BAA4B,CAAC;CAC1C;AAED,MAAM,MAAM,4BAA4B,GACpC,eAAe,GACf,eAAe,GACf,iBAAiB,GACjB,cAAc,GACd,SAAS,GACT,YAAY,GACZ,gBAAgB,CAAC;AAErB,qBAAa,wBAAyB,SAAQ,KAAK;aAE/B,IAAI,EAAE,4BAA4B;aAElC,MAAM,CAAC,EAAE,MAAM;gBAFf,IAAI,EAAE,4BAA4B,EAClD,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,YAAA;CAKlC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,uBAAuB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE,WAAW,IAAI,yBAAyB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,iCAAiC;IAChD,MAAM,EAAE,yBAAyB,CAAC;IAClC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAID,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,iCAAiC,GACzC,0BAA0B,CA+G5B"}

package/dist/vendor/onegent-runtime/vendor-sandbox-egress.js

@@ -0,0 +1,152 @@
+export class VendorSandboxEgressError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "VendorSandboxEgressError";
+    }
+}
+const MAX_AUDIT_ENTRIES = 100;
+export function createBoundedVendorSandboxEgress(options) {
+    const policy = validatePolicy(options.policy);
+    const requestFetch = options.fetch ?? fetch;
+    const now = options.now ?? Date.now;
+    const audit = [];
+    let requestSequence = 0;
+    let windowStartedAt = now();
+    let requestsInWindow = 0;
+    const record = (entry) => {
+        audit.push(Object.freeze({ ...entry }));
+        if (audit.length > MAX_AUDIT_ENTRIES)
+            audit.splice(0, audit.length - MAX_AUDIT_ENTRIES);
+    };
+    return Object.freeze({
+        requestJson: async (request) => {
+            const startedAt = now();
+            const requestId = `${policy.vendor}-${++requestSequence}`;
+            const method = request.method;
+            const url = safeUrl(request.path, policy.allowedOrigin);
+            const baseAudit = {
+                requestId,
+                timestamp: new Date(startedAt).toISOString(),
+                vendor: policy.vendor,
+                resource: request.resource,
+                method,
+                origin: url?.origin ?? policy.allowedOrigin,
+            };
+            const deny = (error) => {
+                record({ ...baseAudit, outcome: "denied", durationMs: elapsed(now, startedAt), errorCode: error.code });
+                throw error;
+            };
+            if (!url || url.origin !== policy.allowedOrigin || url.protocol !== "https:" || url.username || url.password || url.hash) {
+                return deny(new VendorSandboxEgressError("ORIGIN_DENIED", "Vendor sandbox request origin is not allowlisted."));
+            }
+            const resource = policy.resources.find((entry) => entry.id === request.resource);
+            if (!resource) {
+                return deny(new VendorSandboxEgressError("RESOURCE_DENIED", "Vendor sandbox resource is not allowlisted."));
+            }
+            if (method !== resource.method) {
+                return deny(new VendorSandboxEgressError("METHOD_DENIED", "Vendor sandbox HTTP method is not allowlisted for this resource."));
+            }
+            resource.pathPattern.lastIndex = 0;
+            if (!resource.pathPattern.test(`${url.pathname}${url.search}`)) {
+                return deny(new VendorSandboxEgressError("RESOURCE_DENIED", "Vendor sandbox path is not allowlisted for this resource."));
+            }
+            const current = now();
+            if (current - windowStartedAt >= 60_000) {
+                windowStartedAt = current;
+                requestsInWindow = 0;
+            }
+            if (requestsInWindow >= policy.maxRequestsPerMinute) {
+                const error = new VendorSandboxEgressError("RATE_LIMITED", "Vendor sandbox request limit exceeded. Retry after the current one-minute window.");
+                record({ ...baseAudit, outcome: "rate_limited", durationMs: elapsed(now, startedAt), errorCode: error.code });
+                throw error;
+            }
+            requestsInWindow += 1;
+            const controller = new AbortController();
+            let timedOut = false;
+            let timeout;
+            const operation = (async () => {
+                const response = await requestFetch(url, {
+                    method,
+                    headers: request.headers,
+                    redirect: "error",
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    throw new VendorSandboxEgressError("HTTP_ERROR", `Vendor sandbox returned HTTP ${response.status}.`, response.status);
+                }
+                return { payload: await response.json(), status: response.status };
+            })();
+            const timeoutOperation = new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    timedOut = true;
+                    controller.abort();
+                    reject(new VendorSandboxEgressError("TIMEOUT", `Vendor sandbox request exceeded ${policy.timeoutMs} ms.`));
+                }, policy.timeoutMs);
+            });
+            try {
+                const result = await Promise.race([operation, timeoutOperation]);
+                record({ ...baseAudit, outcome: "allowed", durationMs: elapsed(now, startedAt), status: result.status });
+                return result.payload;
+            }
+            catch (cause) {
+                const error = cause instanceof VendorSandboxEgressError
+                    ? cause
+                    : timedOut
+                        ? new VendorSandboxEgressError("TIMEOUT", `Vendor sandbox request exceeded ${policy.timeoutMs} ms.`)
+                        : new VendorSandboxEgressError("REQUEST_FAILED", "Vendor sandbox request failed.");
+                record({
+                    ...baseAudit,
+                    outcome: error.code === "TIMEOUT" ? "timeout" : error.code === "HTTP_ERROR" ? "http_error" : "failed",
+                    durationMs: elapsed(now, startedAt),
+                    status: error.status,
+                    errorCode: error.code,
+                });
+                throw error;
+            }
+            finally {
+                if (timeout)
+                    clearTimeout(timeout);
+            }
+        },
+        getAuditLog: () => audit.map((entry) => ({ ...entry })),
+    });
+}
+function validatePolicy(policy) {
+    const origin = new URL(policy.allowedOrigin);
+    if (origin.protocol !== "https:" || origin.origin !== policy.allowedOrigin || origin.pathname !== "/" || origin.search || origin.hash) {
+        throw new Error("Vendor sandbox allowedOrigin must be an exact HTTPS origin without a path.");
+    }
+    if (!policy.vendor.trim())
+        throw new Error("Vendor sandbox policy vendor is required.");
+    if (!Number.isSafeInteger(policy.timeoutMs) || policy.timeoutMs < 100 || policy.timeoutMs > 30_000) {
+        throw new Error("Vendor sandbox timeoutMs must be an integer from 100 to 30000.");
+    }
+    if (!Number.isSafeInteger(policy.maxRequestsPerMinute) || policy.maxRequestsPerMinute < 1 || policy.maxRequestsPerMinute > 60) {
+        throw new Error("Vendor sandbox maxRequestsPerMinute must be an integer from 1 to 60.");
+    }
+    if (policy.resources.length === 0 || new Set(policy.resources.map((entry) => entry.id)).size !== policy.resources.length) {
+        throw new Error("Vendor sandbox policy requires unique resource rules.");
+    }
+    return Object.freeze({
+        ...policy,
+        resources: Object.freeze(policy.resources.map((entry) => Object.freeze({
+            ...entry,
+            pathPattern: new RegExp(entry.pathPattern.source, entry.pathPattern.flags),
+        }))),
+    });
+}
+function safeUrl(path, origin) {
+    try {
+        return new URL(path, `${origin}/`);
+    }
+    catch {
+        return undefined;
+    }
+}
+function elapsed(now, startedAt) {
+    return Math.max(0, Math.round(now() - startedAt));
+}

package/package.json

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