bootproof 0.1.0 → 0.4.0

package/dist/plan.d.ts

@@ -1,4 +1,6 @@
 import type { Inference, RunPlan } from "./types.js";
+export declare const REPAIRED_GENERATED_COMPOSE_MARKER = "# BootProof verified repair: remap-conflicting-service-port";
+export declare function repoComposeRepairFile(repoComposeFile: string): string;
 export declare function composeFileFor(inf: Inference): string | null;
 export declare function envExampleFor(inf: Inference): string | null;
 export declare function buildPlan(inf: Inference, provider: "docker" | "local"): RunPlan;

package/dist/plan.js

@@ -6,9 +6,23 @@ const SERVICE_IMAGES = {
     redis: { image: "redis:7-alpine", port: 6379, env: {} },
     mongodb: { image: "mongo:7", port: 27017, env: {} },
 };
+export const REPAIRED_GENERATED_COMPOSE_MARKER = "# BootProof verified repair: remap-conflicting-service-port";
+export function repoComposeRepairFile(repoComposeFile) {
+    const directory = path.posix.dirname(repoComposeFile.replace(/\\/g, "/"));
+    const file = "docker-compose.bootproof.override.yml";
+    return directory === "." ? file : path.posix.join(directory, file);
+}
 export function composeFileFor(inf) {
+    if (inf.repoComposeFile)
+        return null;
     if (!inf.services.length)
         return null;
+    const existingPath = path.join(inf.repoPath, "docker-compose.bootproof.yml");
+    if (fs.existsSync(existingPath)) {
+        const existing = fs.readFileSync(existingPath, "utf8");
+        if (existing.includes(REPAIRED_GENERATED_COMPOSE_MARKER))
+            return existing;
+    }
     const lines = ["# Generated by bootproof — review before use. Standard compose; no bootproof runtime required.", "services:"];
     for (const s of inf.services) {
         const spec = SERVICE_IMAGES[s.kind];
@@ -47,16 +61,42 @@ export function envExampleFor(inf) {
 }
 export function buildPlan(inf, provider) {
     const steps = [];
-    if (inf.services.length && provider === "docker") {
-        steps.push({ id: "services", kind: "service", command: "docker compose -f docker-compose.bootproof.yml up -d", description: `start ${inf.services.map(s => s.kind).join(", ")} in containers`, required: true });
+    const runsSourceComposeApplication = provider === "docker" &&
+        Boolean(inf.repoComposeFile) &&
+        inf.composeHealthCandidates.length > 0;
+    if (provider === "docker" && inf.repoComposeFile) {
+        const repairedCompose = repoComposeRepairFile(inf.repoComposeFile);
+        const usesRepairedCopy = fs.existsSync(path.join(inf.repoPath, repairedCompose));
+        steps.push({
+            id: "services",
+            kind: "service",
+            command: `docker compose -f ${usesRepairedCopy ? repairedCompose : inf.repoComposeFile} up -d`,
+            description: usesRepairedCopy
+                ? "use the BootProof repaired copy of the repository Compose file"
+                : "defer to the repository's own compose file",
+            required: true,
+        });
     }
-    if (inf.installCommand) {
-        steps.push({ id: "install", kind: "install", command: inf.installCommand, description: "install dependencies", required: inf.dependencyInstallRequired });
+    else if (inf.services.length && provider === "docker") {
+        steps.push({ id: "services", kind: "service", command: "docker compose -f docker-compose.bootproof.yml up -d", description: `start ${inf.services.map(s => s.kind).join(", ")} in containers`, required: true });
     }
-    if (inf.appCommand) {
-        steps.push({ id: "start-app", kind: "start-app", command: inf.appCommand, description: `start app (${inf.appCommandSource})`, required: true });
+    if (!runsSourceComposeApplication) {
+        for (const preparation of inf.preparationCommands) {
+            steps.push({
+                id: preparation.id,
+                kind: preparation.kind,
+                command: preparation.command,
+                description: `${preparation.description} (${preparation.source})`,
+                required: true,
+            });
+        }
+        if (inf.appCommand) {
+            steps.push({ id: "start-app", kind: "start-app", command: inf.appCommand, description: `start app (${inf.appCommandSource})`, required: true });
+        }
     }
-    const healthCandidates = [...inf.healthCandidates];
+    const healthCandidates = runsSourceComposeApplication
+        ? [...inf.composeHealthCandidates]
+        : [...inf.healthCandidates];
     const healthUrl = healthCandidates[0] ?? "";
     if (inf.isApplication && healthUrl) {
         steps.push({ id: "health", kind: "health", description: `poll ${healthUrl} for an HTTP response`, required: true });
@@ -66,6 +106,8 @@ export function buildPlan(inf, provider) {
         steps,
         healthUrl,
         healthCandidates,
+        observedPort: inf.observedPort,
+        healthCandidateSource: inf.healthCandidateSource,
         generatedFiles: [
             ...(composeFileFor(inf) ? [{ path: "docker-compose.bootproof.yml", purpose: "service containers" }] : []),
             ...(envExampleFor(inf) ? [{ path: ".env.bootproof.example", purpose: "suggested local env values (never auto-applied)" }] : []),

package/dist/proof.d.ts

@@ -1,6 +1,45 @@
-import type { Attestation, ObservedStep, RunPlan, FailureClass } from "./types.js";
-export declare const TOOL_ID = "bootproof@0.1.0";
+import type { Attestation, AttestationTrust, ObservedStep, RunPlan, FailureClass, HealthEvidence, VerificationMode, ExternalVerificationClassification } from "./types.js";
+export declare const TOOL_ID = "bootproof@0.4.0";
+export type { AttestationTrust } from "./types.js";
+export type SignerTrustTier = "invalid" | "self" | "known" | "unknown-foreign";
+export interface SignatureTrustResult {
+    integrityValid: boolean;
+    tier: SignerTrustTier;
+    fingerprint: string | null;
+    label: string | null;
+}
 export declare function gitInfo(repo: string): Attestation["repo"];
+export declare function knownSignersPath(): string;
+export interface RotationResult {
+    schema: "bootproof/key-rotation/v1";
+    rotatedAt: string;
+    oldPublicKey: string;
+    newPublicKey: string;
+    backedUpTo: string | null;
+    reSignedAttestation: boolean;
+}
+/**
+ * Rotate the local ed25519 signing key. The old key's public key is archived
+ * (so existing attestations remain independently verifiable), a new keypair is
+ * generated, and the latest attestation in the given repo is optionally
+ * re-signed with the new key.
+ *
+ * Rotation does NOT invalidate existing attestations — they still carry the
+ * old public key inline and verify with it. Rotation only affects what key
+ * future attestations will be signed with.
+ */
+export declare function rotateSigner(opts?: {
+    repo?: string;
+    resignAttestation?: boolean;
+    backup?: boolean;
+}): RotationResult;
+export declare function signerFingerprint(publicKeyPem: string): string;
+export declare function trustSigner(publicKeyPem: string, label?: string): {
+    fingerprint: string;
+    firstSeenAt: string;
+    label: string | null;
+};
+export declare function evaluateDetachedSignature(body: Buffer, signature: string | null | undefined, publicKeyPem: string | null | undefined): SignatureTrustResult;
 export declare function buildAttestation(input: {
     repo: string;
     plan: RunPlan;
@@ -9,16 +48,53 @@ export declare function buildAttestation(input: {
     booted: boolean;
     healthVerified: boolean;
     healthObservation: string | null;
+    healthEvidence?: HealthEvidence | null;
     observedHealthCandidates?: string[];
     failureClass: FailureClass | null;
     failureEvidence: string | null;
     explanation: string;
+    verificationMode?: VerificationMode;
+    bootproofOrchestrated?: boolean;
+    externalHealthUrl?: string | null;
+    observedStatus?: number | null;
+    observedFinalUrl?: string | null;
+    observedAt?: string | null;
+    responseSnippet?: string;
+    classification?: ExternalVerificationClassification | null;
+    trust?: AttestationTrust;
 }): Attestation;
+/**
+ * Detect GitHub Actions OIDC environment. Present only when the workflow has
+ * `permissions: id-token: write`. The presence of these env vars IS the consent —
+ * the workflow author explicitly granted the OIDC scope.
+ */
+export declare function detectOidcEnv(env?: NodeJS.ProcessEnv): {
+    requestUrl: string;
+    requestToken: string;
+} | null;
+/**
+ * Fetch the OIDC JWT from GitHub Actions and decode its claims (without verification —
+ * verification is the receiver's job, not the signer's). Returns a compact record of
+ * claims suitable for embedding in the attestation trust block.
+ */
+export declare function fetchOidcClaims(requestUrl: string, requestToken: string, fetchImpl?: typeof fetch): Promise<Record<string, string>>;
+/**
+ * Resolve the trust block for an attestation. When `--ci-oidc` is requested and
+ * the GitHub Actions OIDC environment is present, fetch the OIDC token and return
+ * a ci_oidc_signed trust block. Otherwise return local_developer_signed.
+ */
+export declare function resolveTrust(opts?: {
+    ciOidc?: boolean;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: typeof fetch;
+}): Promise<AttestationTrust>;
 export declare function signDetached(body: Buffer): {
     signature: string;
     publicKeyPem: string;
 };
 export declare function verifyDetached(body: Buffer, signature: string, publicKeyPem: string): boolean;
 export declare function verifySignature(att: Attestation): boolean;
+export declare function evaluateAttestationSignature(att: Attestation): SignatureTrustResult;
+export declare function currentGitHead(repo: string): string | null;
 export declare function attestationPath(repo: string): string;
 export declare function writeAttestation(repo: string, att: Attestation): string;

package/dist/proof.js

@@ -3,11 +3,13 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
-export const TOOL_ID = "bootproof@0.1.0";
+import { buildExecutionEnv } from "./exec.js";
+import { redactJsonValue } from "./redact.js";
+export const TOOL_ID = "bootproof@0.4.0";
 export function gitInfo(repo) {
     const git = (...args) => {
         try {
-            return execFileSync("git", ["-C", repo, ...args], { encoding: "utf8" }).trim();
+            return execFileSync("git", ["-C", repo, ...args], { encoding: "utf8", env: buildExecutionEnv() }).trim();
         }
         catch {
             return null;
@@ -18,7 +20,7 @@ export function gitInfo(repo) {
     const status = git("status", "--porcelain");
     return {
         path: repo,
-        remote: git("remote", "get-url", "origin"),
+        remote: git("config", "--get", "remote.origin.url"),
         commit: git("rev-parse", "HEAD"),
         dirty: status === null ? null : status.length > 0,
     };
@@ -26,6 +28,9 @@ export function gitInfo(repo) {
 function signerKeyPath() {
     return path.join(os.homedir(), ".bootproof", "signer.json");
 }
+export function knownSignersPath() {
+    return path.join(os.homedir(), ".bootproof", "known_signers.json");
+}
 function loadOrCreateSigner() {
     const p = signerKeyPath();
     if (fs.existsSync(p)) {
@@ -39,27 +44,204 @@ function loadOrCreateSigner() {
     fs.writeFileSync(p, JSON.stringify({ privateKeyPem, publicKeyPem }), { mode: 0o600 });
     return { privateKey: crypto.createPrivateKey(privateKeyPem), publicKeyPem };
 }
+/**
+ * Rotate the local ed25519 signing key. The old key's public key is archived
+ * (so existing attestations remain independently verifiable), a new keypair is
+ * generated, and the latest attestation in the given repo is optionally
+ * re-signed with the new key.
+ *
+ * Rotation does NOT invalidate existing attestations — they still carry the
+ * old public key inline and verify with it. Rotation only affects what key
+ * future attestations will be signed with.
+ */
+export function rotateSigner(opts = {}) {
+    const p = signerKeyPath();
+    const oldKey = fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, "utf8")) : null;
+    const oldPublicKeyPem = oldKey?.publicKeyPem ?? null;
+    // Generate the new keypair.
+    const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519");
+    const newPrivateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+    const newPublicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
+    // Back up the old key before overwriting (unless explicitly skipped).
+    let backedUpTo = null;
+    if (opts.backup !== false && oldKey) {
+        const backupDir = path.join(os.homedir(), ".bootproof", "archived-keys");
+        fs.mkdirSync(backupDir, { recursive: true, mode: 0o700 });
+        const backupName = `signer-${new Date().toISOString().replace(/[:.]/g, "-")}.json`;
+        backedUpTo = path.join(backupDir, backupName);
+        fs.writeFileSync(backedUpTo, JSON.stringify(oldKey, null, 2), { mode: 0o600 });
+    }
+    // Write the new key.
+    fs.mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(p, JSON.stringify({ privateKeyPem: newPrivateKeyPem, publicKeyPem: newPublicKeyPem }), { mode: 0o600 });
+    // Optionally re-sign the latest attestation with the new key.
+    let reSigned = false;
+    if (opts.resignAttestation && opts.repo) {
+        const attPath = attestationPath(opts.repo);
+        if (fs.existsSync(attPath)) {
+            const att = JSON.parse(fs.readFileSync(attPath, "utf8"));
+            // Re-sign: the canonical body excludes signature and signer fields.
+            const body = canonicalBody(att);
+            const newPrivateKey = crypto.createPrivateKey(newPrivateKeyPem);
+            att.signature = crypto.sign(null, body, newPrivateKey).toString("base64");
+            att.signer = { publicKey: newPublicKeyPem, algorithm: "ed25519" };
+            fs.writeFileSync(attPath, JSON.stringify(att, null, 2) + "\n");
+            reSigned = true;
+        }
+    }
+    return {
+        schema: "bootproof/key-rotation/v1",
+        rotatedAt: new Date().toISOString(),
+        oldPublicKey: oldPublicKeyPem ?? "(no prior key existed)",
+        newPublicKey: newPublicKeyPem,
+        backedUpTo,
+        reSignedAttestation: reSigned,
+    };
+}
+function localSignerPublicKey() {
+    const p = signerKeyPath();
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const saved = JSON.parse(fs.readFileSync(p, "utf8"));
+        return typeof saved.publicKeyPem === "string" ? saved.publicKeyPem : null;
+    }
+    catch {
+        return null;
+    }
+}
+function emptyKnownSignerStore() {
+    return { schema: "bootproof/known-signers/v1", signers: {} };
+}
+function readKnownSignerStore() {
+    const p = knownSignersPath();
+    if (!fs.existsSync(p))
+        return emptyKnownSignerStore();
+    try {
+        const value = JSON.parse(fs.readFileSync(p, "utf8"));
+        if (value.schema !== "bootproof/known-signers/v1" || !value.signers || typeof value.signers !== "object") {
+            return emptyKnownSignerStore();
+        }
+        return { schema: value.schema, signers: value.signers };
+    }
+    catch {
+        return emptyKnownSignerStore();
+    }
+}
+export function signerFingerprint(publicKeyPem) {
+    const publicKey = crypto.createPublicKey(publicKeyPem);
+    const spki = publicKey.export({ type: "spki", format: "der" });
+    return `sha256:${crypto.createHash("sha256").update(spki).digest("hex")}`;
+}
+export function trustSigner(publicKeyPem, label) {
+    const fingerprint = signerFingerprint(publicKeyPem);
+    const store = readKnownSignerStore();
+    const existing = store.signers[fingerprint];
+    const record = existing ?? {
+        firstSeenAt: new Date().toISOString(),
+        ...(label ? { label } : {}),
+    };
+    if (label)
+        record.label = label;
+    store.signers[fingerprint] = record;
+    const p = knownSignersPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(p, JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+    return {
+        fingerprint,
+        firstSeenAt: record.firstSeenAt,
+        label: record.label ?? null,
+    };
+}
+function signerTrust(publicKeyPem) {
+    let fingerprint;
+    try {
+        fingerprint = signerFingerprint(publicKeyPem);
+    }
+    catch {
+        return { tier: "invalid", fingerprint: null, label: null };
+    }
+    const localPublicKey = localSignerPublicKey();
+    if (localPublicKey) {
+        try {
+            if (signerFingerprint(localPublicKey) === fingerprint) {
+                return { tier: "self", fingerprint, label: null };
+            }
+        }
+        catch {
+            // A malformed local signer cannot establish trust in a foreign artifact.
+        }
+    }
+    const known = readKnownSignerStore().signers[fingerprint];
+    if (known)
+        return { tier: "known", fingerprint, label: known.label ?? null };
+    return { tier: "unknown-foreign", fingerprint, label: null };
+}
+export function evaluateDetachedSignature(body, signature, publicKeyPem) {
+    if (!signature || !publicKeyPem || !verifyDetached(body, signature, publicKeyPem)) {
+        return { integrityValid: false, tier: "invalid", fingerprint: null, label: null };
+    }
+    return { integrityValid: true, ...signerTrust(publicKeyPem) };
+}
 function canonicalBody(att) {
     const { signature: _s, signer: _k, ...body } = att;
     return Buffer.from(JSON.stringify(body));
 }
 export function buildAttestation(input) {
+    const verificationMode = input.verificationMode ?? "bootproof-orchestrated";
+    const bootproofOrchestrated = verificationMode === "external-health"
+        ? false
+        : input.bootproofOrchestrated ?? true;
+    const redactionsApplied = new Set();
+    const redact = (value) => {
+        const redacted = redactJsonValue(value);
+        for (const rule of redacted.applied)
+            redactionsApplied.add(rule);
+        return redacted.value;
+    };
+    const repo = gitInfo(input.repo);
+    const persistedRepo = {
+        ...repo,
+        remote: redact(repo.remote),
+    };
+    const persistedPlan = redact(input.plan);
+    const persistedObserved = redact(input.observed);
+    const persistedHealthObservation = redact(input.healthObservation);
+    const persistedHealthEvidence = redact(input.healthEvidence ?? null);
+    const persistedObservedHealthCandidates = redact(input.observedHealthCandidates ?? []);
+    const persistedFailureEvidence = redact(input.failureEvidence);
+    const persistedExplanation = redact(input.explanation);
+    const persistedExternalHealthUrl = redact(input.externalHealthUrl ?? null);
+    const persistedObservedFinalUrl = redact(input.observedFinalUrl ?? null);
+    const persistedResponseSnippet = redact(input.responseSnippet ?? "");
     const att = {
         schema: "bootproof/attestation/v1",
         tool: TOOL_ID,
-        repo: gitInfo(input.repo),
+        verificationMode,
+        bootproofOrchestrated,
+        externalHealthUrl: persistedExternalHealthUrl,
+        observedStatus: input.observedStatus ?? null,
+        observedFinalUrl: persistedObservedFinalUrl,
+        observedAt: input.observedAt ?? null,
+        responseSnippet: persistedResponseSnippet,
+        classification: input.classification ?? null,
+        redactionsApplied: [...redactionsApplied].sort(),
+        repo: persistedRepo,
         environment: { os: `${os.platform()} ${os.release()}`, arch: os.arch(), node: process.version },
-        trust: { level: "local_developer_signed", signer: "local_ed25519", oidc: null },
-        plan: input.plan,
-        observed: input.observed,
+        trust: input.trust ?? { level: "local_developer_signed", signer: "local_ed25519", oidc: null },
+        plan: persistedPlan,
+        observed: persistedObserved,
         result: {
             booted: input.booted,
             healthVerified: input.healthVerified,
-            healthObservation: input.healthObservation,
-            observedHealthCandidates: input.observedHealthCandidates ?? [],
+            healthObservation: persistedHealthObservation,
+            healthEvidence: persistedHealthEvidence,
+            observedHealthCandidates: persistedObservedHealthCandidates,
+            observedPort: persistedPlan.observedPort ?? null,
+            healthCandidateSource: persistedPlan.healthCandidateSource ?? "inferred",
             failureClass: input.failureClass,
-            failureEvidence: input.failureEvidence,
-            explanation: input.explanation,
+            failureEvidence: persistedFailureEvidence,
+            explanation: persistedExplanation,
         },
         startedAt: input.startedAt,
         finishedAt: new Date().toISOString(),
@@ -71,6 +253,67 @@ export function buildAttestation(input) {
     att.signer = { publicKey: publicKeyPem, algorithm: "ed25519" };
     return att;
 }
+/**
+ * Detect GitHub Actions OIDC environment. Present only when the workflow has
+ * `permissions: id-token: write`. The presence of these env vars IS the consent —
+ * the workflow author explicitly granted the OIDC scope.
+ */
+export function detectOidcEnv(env = process.env) {
+    const url = env.ACTIONS_ID_TOKEN_REQUEST_URL?.trim();
+    const token = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN?.trim();
+    if (!url || !token)
+        return null;
+    return { requestUrl: url, requestToken: token };
+}
+/**
+ * Fetch the OIDC JWT from GitHub Actions and decode its claims (without verification —
+ * verification is the receiver's job, not the signer's). Returns a compact record of
+ * claims suitable for embedding in the attestation trust block.
+ */
+export async function fetchOidcClaims(requestUrl, requestToken, fetchImpl = fetch) {
+    const url = new URL(requestUrl);
+    url.searchParams.set("audience", "bootproof.dev");
+    const response = await fetchImpl(url.toString(), {
+        headers: { authorization: `bearer ${requestToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`OIDC token request failed with HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    if (!body.value || typeof body.value !== "string") {
+        throw new Error("OIDC token response did not contain a 'value' field");
+    }
+    // Decode the JWT payload (middle segment). No verification — the receiver verifies.
+    const parts = body.value.split(".");
+    if (parts.length !== 3)
+        throw new Error("OIDC token is not a valid JWT");
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    // Extract the claims that matter for provenance. Stringify everything for the schema.
+    const claims = {};
+    for (const key of ["iss", "sub", "aud", "ref", "repository", "repository_owner", "run_id", "run_attempt", "event_name", "workflow", "job_workflow_ref"]) {
+        if (payload[key] !== undefined && payload[key] !== null) {
+            claims[key] = String(payload[key]);
+        }
+    }
+    return claims;
+}
+/**
+ * Resolve the trust block for an attestation. When `--ci-oidc` is requested and
+ * the GitHub Actions OIDC environment is present, fetch the OIDC token and return
+ * a ci_oidc_signed trust block. Otherwise return local_developer_signed.
+ */
+export async function resolveTrust(opts = {}) {
+    if (!opts.ciOidc) {
+        return { level: "local_developer_signed", signer: "local_ed25519", oidc: null };
+    }
+    const oidcEnv = detectOidcEnv(opts.env);
+    if (!oidcEnv) {
+        throw new Error("--ci-oidc was requested but ACTIONS_ID_TOKEN_REQUEST_URL/ACTIONS_ID_TOKEN_REQUEST_TOKEN are not set. "
+            + "Ensure the workflow has `permissions: id-token: write`.");
+    }
+    const claims = await fetchOidcClaims(oidcEnv.requestUrl, oidcEnv.requestToken, opts.fetchImpl);
+    return { level: "ci_oidc_signed", signer: "local_ed25519", oidc: claims };
+}
 export function signDetached(body) {
     const { privateKey, publicKeyPem } = loadOrCreateSigner();
     return { signature: crypto.sign(null, body, privateKey).toString("base64"), publicKeyPem };
@@ -86,11 +329,21 @@ export function verifyDetached(body, signature, publicKeyPem) {
 export function verifySignature(att) {
     if (!att.signature || !att.signer)
         return false;
+    return verifyDetached(canonicalBody(att), att.signature, att.signer.publicKey);
+}
+export function evaluateAttestationSignature(att) {
+    return evaluateDetachedSignature(canonicalBody(att), att.signature, att.signer?.publicKey);
+}
+export function currentGitHead(repo) {
     try {
-        return crypto.verify(null, canonicalBody(att), crypto.createPublicKey(att.signer.publicKey), Buffer.from(att.signature, "base64"));
+        return execFileSync("git", ["-C", repo, "rev-parse", "HEAD"], {
+            encoding: "utf8",
+            env: buildExecutionEnv(),
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
     }
     catch {
-        return false;
+        return null;
     }
 }
 export function attestationPath(repo) {

package/dist/receipt.d.ts

@@ -0,0 +1,52 @@
+import type { Attestation } from "./types.js";
+interface ReceiptRecord {
+    schema: string;
+    id: string;
+    capturedAt: string;
+    capturedBy: string;
+    trust: {
+        level: string;
+        signer: string;
+        oidc: string | null;
+        upgradePath: string[];
+    };
+    repo: {
+        url: string;
+        commit: string;
+        branch: string;
+        label: string;
+    };
+    inference: {
+        language: string;
+        packageManager: string;
+        startCommand: string;
+    } | null;
+    plan: Array<{
+        step: string;
+        command: string;
+        exitCode: number;
+        durationMs: number;
+    }>;
+    log: Array<{
+        t: number;
+        level: string;
+        line: string;
+    }>;
+    observed: {
+        kind: string;
+        url?: string;
+        status?: number;
+        latencyMs?: number;
+        body?: string;
+        signal?: string | null;
+        code?: number;
+        windowMs?: number;
+        exitCode?: number;
+    };
+    booted: boolean;
+    healthVerified: boolean;
+    failureClass: string | null;
+}
+declare function attestationToRecord(att: Attestation): ReceiptRecord;
+export declare function emitLivingReceipt(att: Attestation, outPath: string): string;
+export { attestationToRecord };