witnora 0.8.1 → 0.9.0

package/dist/vendor/onegent-runtime/browser-enforcement-runtime.js

@@ -0,0 +1,344 @@
+import { createPublicKey, randomBytes, randomUUID, verify } from "node:crypto";
+import { canonicalJson, sha256, signDigest } from "./trust-crypto.js";
+import { isRegisteredControlledActionAdapter, isRegisteredIndependentOutcomeProbe } from "./controlled-adapter.js";
+export const BROWSER_ENFORCEMENT_PROTOCOL = "agentcert.browser_enforcement.v0.2";
+export const EXECUTION_GRANT_CONTEXT = "agentcert.execution-grant.v0.2";
+export const RUNTIME_CLAIM_CONTEXT = "onegent.runtime-claim.v0.2";
+export const EXECUTION_SESSION_CONTEXT = "onegent.execution-session.v0.2";
+export const EVENT_CONTEXT = "onegent.execution-event.v0.2";
+export const EVENT_CHECKPOINT_CONTEXT = "onegent.event-checkpoint.v0.2";
+export const OUTCOME_CONTEXT = "onegent.outcome-attestation.v0.2";
+export const RECONCILIATION_CONTEXT = "onegent.reconciliation-report.v0.2";
+export async function executeBrowserEnforcement(options) {
+    const now = options.now ?? (() => new Date());
+    verifyHostedExecutionGrant(options.grant, options.hostedIssuerKeys, now(), options.clockSkewMs ?? 30_000);
+    assertBindings(options);
+    if (!isRegisteredControlledActionAdapter(options.adapter))
+        throw new Error("ADAPTER_UNREGISTERED");
+    if (!isRegisteredIndependentOutcomeProbe(options.outcomeProbe))
+        throw new Error("OUTCOME_PROBE_UNREGISTERED");
+    if (options.outcomeProbe.name === options.adapter.name)
+        throw new Error("OUTCOME_NOT_INDEPENDENT");
+    const grant = options.grant.payload;
+    const executionSessionId = randomUUID();
+    const runtimeClaim = signRuntimeObject({
+        protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+        objectType: "RuntimeClaim",
+        signatureContext: RUNTIME_CLAIM_CONTEXT,
+        runtimeIdentityId: options.runtime.runtimeIdentityId,
+        executionGrantId: grant.executionGrantId,
+        executionGrantDigest: options.grant.payloadSha256,
+        actionId: grant.actionId,
+        principalIdentityAssertionId: grant.principalIdentityAssertionId,
+        principalIdentityDigest: grant.principalIdentityDigest,
+        principalIdentityProvider: grant.principalIdentityProvider,
+        executionSessionId,
+        claimNonce: randomBytes(24).toString("base64url"),
+        claimedAt: now().toISOString(),
+        runtimeKeyId: options.runtime.runtimeKeyId,
+        idempotencyKey: `claim:${grant.jti}`,
+    }, options.runtime.signer);
+    await options.claimGrant(runtimeClaim);
+    const credentialLeaseId = options.credentialLease.credentialLeaseId ?? randomUUID();
+    const startedAt = now().toISOString();
+    const genesis = sha256(canonicalJson({ executionSessionId, executionGrantDigest: options.grant.payloadSha256, runtimeIdentityId: options.runtime.runtimeIdentityId }));
+    const session = signRuntimeObject({
+        protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+        objectType: "ExecutionSessionAttestation",
+        signatureContext: EXECUTION_SESSION_CONTEXT,
+        executionSessionId,
+        executionGrantId: grant.executionGrantId,
+        executionGrantDigest: options.grant.payloadSha256,
+        actionId: grant.actionId,
+        actionIntentDigest: grant.actionIntentDigest,
+        runtimeIdentityId: options.runtime.runtimeIdentityId,
+        runtimeKeyId: options.runtime.runtimeKeyId,
+        adapterId: grant.adapterId,
+        adapterVersion: options.adapterVersion,
+        browserContextIdDigest: sha256(`browser-context:${executionSessionId}`),
+        credentialLeaseId,
+        credentialIsolationMode: options.credentialLease.isolationMode,
+        targetAudience: grant.targetAudience,
+        allowedOrigins: [...grant.allowedOrigins],
+        startedAt,
+        sessionExpiresAt: grant.expiresAt,
+        eventChainGenesisHash: genesis,
+    }, options.runtime.signer);
+    const events = [];
+    let previousHash = genesis;
+    const append = async (eventType, payload = {}) => {
+        const redactedPayload = redactAndBound(payload);
+        const event = {
+            protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+            objectType: "ExecutionEvent",
+            signatureContext: EVENT_CONTEXT,
+            eventId: randomUUID(),
+            actionId: grant.actionId,
+            executionSessionId,
+            sequence: events.length + 1,
+            previousEventHash: previousHash,
+            eventType,
+            sourceIdentityId: options.runtime.runtimeIdentityId,
+            sourceTimestamp: now().toISOString(),
+            receivedTimestamp: now().toISOString(),
+            payloadDigest: sha256(canonicalJson(redactedPayload)),
+            redactedPayload,
+        };
+        const signed = signRuntimeObject(event, options.runtime.signer);
+        previousHash = signed.payloadSha256;
+        events.push(signed);
+        await options.recorder.append(eventType, { actionId: grant.actionId, executionSessionId, ...redactedPayload });
+    };
+    const leaseIssuedAt = now().toISOString();
+    const providerReferenceDigest = sha256(options.credentialLease.providerReference);
+    const credentialLease = {
+        credentialLeaseId,
+        tenantId: grant.tenantId,
+        actionId: grant.actionId,
+        executionSessionId,
+        providerType: options.credentialLease.providerType,
+        providerReference: `opaque:${providerReferenceDigest}`,
+        targetAudience: grant.targetAudience,
+        scopeDigest: sha256(canonicalJson({ allowedOrigins: grant.allowedOrigins, operation: grant.allowedOperation, resource: grant.allowedResource })),
+        isolationMode: options.credentialLease.isolationMode,
+        issuedAt: leaseIssuedAt,
+        expiresAt: options.credentialLease.expiresAt,
+        status: "ACTIVE",
+    };
+    let leaseRevoked = false;
+    const revokeCredentialLease = async () => {
+        if (leaseRevoked)
+            return;
+        try {
+            await options.credentialLease.revoke?.();
+            credentialLease.status = "REVOKED";
+        }
+        catch (error) {
+            credentialLease.status = "FAILED";
+            throw error;
+        }
+        finally {
+            const revokedAt = now().toISOString();
+            credentialLease.revokedAt = revokedAt;
+            leaseRevoked = true;
+            await append("CREDENTIAL_LEASE_REVOKED", { credentialLeaseId, revokedAt, status: credentialLease.status });
+        }
+    };
+    try {
+        await append("EXECUTION_GRANT_VERIFIED", { executionGrantDigest: options.grant.payloadSha256 });
+        await append("EXECUTION_GRANT_CLAIMED", { executionGrantId: grant.executionGrantId, claimDigest: runtimeClaim.payloadSha256 });
+        await append("EXECUTION_SESSION_STARTED", { executionSessionDigest: session.payloadSha256 });
+        await append("CREDENTIAL_LEASE_ACTIVATED", { credentialLeaseId, providerReferenceDigest, isolationMode: options.credentialLease.isolationMode });
+        await append("BROWSER_CONTEXT_CREATED", { browserContextIdDigest: session.payload.browserContextIdDigest });
+        await append("TARGET_NAVIGATION", { targetAudience: grant.targetAudience, origin: grant.allowedOrigins[0] });
+        await append("AUTHORIZED_ACTION_PREPARED", { operation: grant.allowedOperation, resource: grant.allowedResource });
+        const finalParametersDigest = sha256(canonicalJson(options.approvedParameters));
+        if (finalParametersDigest !== grant.parametersDigest) {
+            throw new Error("PARAMETERS_DIGEST_MISMATCH");
+        }
+        await append("FINAL_PARAMETERS_VERIFIED", { parametersDigest: finalParametersDigest });
+        await append("HIGH_RISK_SUBMISSION_STARTED", { actionId: grant.actionId });
+        const adapterResult = await options.adapter.execute(options.action, { idempotencyKey: executionSessionId, attempt: 1 });
+        const execution = {
+            method: adapterResult.method ?? "LOCAL_ADAPTER",
+            status: "COMPLETED",
+            targetSystem: adapterResult.targetSystem ?? options.action.targetSystem,
+            previousState: adapterResult.previousState,
+            observedState: adapterResult.observedState,
+            rollbackToken: adapterResult.rollbackToken,
+        };
+        await options.markConsumed(grant.executionGrantId, executionSessionId);
+        await append("HIGH_RISK_SUBMISSION_COMPLETED", { targetSystem: execution.targetSystem });
+        await append("TARGET_RESPONSE_OBSERVED", { observedStateDigest: sha256(canonicalJson(execution.observedState ?? {})) });
+        await append("OUTCOME_PROBE_STARTED", { probe: options.outcomeProbe.name });
+        const observation = await options.outcomeProbe.observe(options.action, execution);
+        await append("OUTCOME_OBSERVED", { observationId: observation.observationId, source: observation.source, observedStateDigest: sha256(canonicalJson(observation.observedState)) });
+        const predicateDigest = sha256(canonicalJson(options.outcomePredicate));
+        const expectedDigest = sha256(canonicalJson(options.action.proposedAfterState));
+        const observedDigest = sha256(canonicalJson(observation.observedState));
+        const outcomeResult = subsetMatches(options.action.proposedAfterState, observation.observedState) ? "SATISFIED" : "NOT_SATISFIED";
+        const outcomeAttestation = signRuntimeObject({
+            protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+            objectType: "OutcomeAttestation",
+            signatureContext: OUTCOME_CONTEXT,
+            outcomeAttestationId: randomUUID(),
+            actionId: grant.actionId,
+            executionSessionId,
+            executionGrantId: grant.executionGrantId,
+            predicateId: "expected_state_subset",
+            predicateVersion: "1",
+            predicateDigest,
+            expectedStateDigest: expectedDigest,
+            observedStateDigest: observedDigest,
+            result: outcomeResult,
+            observationMethod: "TARGET_AUDIT_LOG",
+            observationIndependence: "SEPARATE_READ_ONLY_PROBE",
+            observationSource: observation.source,
+            sourceEvidenceDigest: sha256(canonicalJson(observation)),
+            evidenceReferences: [`target-audit:${observation.observationId}`],
+            collectorIdentityId: options.runtime.runtimeIdentityId,
+            collectorKeyId: options.runtime.runtimeKeyId,
+            collectedAt: observation.observedAt,
+            confidence: 1,
+            limitations: ["The reference probe reads a dedicated sandbox audit source; it is not hardware attested."],
+        }, options.runtime.signer);
+        await revokeCredentialLease();
+        await append("EXECUTION_SESSION_COMPLETED", { outcomeAttestationDigest: outcomeAttestation.payloadSha256 });
+        const auditEvents = await options.targetAuditSource.listEvents(startedAt, now().toISOString());
+        const matching = auditEvents.filter((event) => event.actionId === grant.actionId && event.executionSessionId === executionSessionId && event.operation === grant.allowedOperation && event.resource === grant.allowedResource && event.parametersDigest === grant.parametersDigest);
+        const unmatchedTargetEvents = auditEvents.filter((event) => !matching.includes(event)).map((event) => event.targetEventId);
+        const duplicateMatches = matching.length > 1 ? matching.slice(1).map((event) => event.targetEventId) : [];
+        const reconciliationResult = options.targetAuditSource.exclusiveCredential && matching.length === 1 && !unmatchedTargetEvents.length && !duplicateMatches.length ? "PASSED" : unmatchedTargetEvents.length || duplicateMatches.length ? "BYPASS_DETECTED" : "INCOMPLETE";
+        const reconciliationReport = signRuntimeObject({
+            protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+            objectType: "ReconciliationReport",
+            signatureContext: RECONCILIATION_CONTEXT,
+            reconciliationReportId: randomUUID(),
+            tenantId: grant.tenantId,
+            actionId: grant.actionId,
+            executionSessionId,
+            targetSystem: grant.targetAudience,
+            accountOrCredentialReferenceDigest: providerReferenceDigest,
+            reconciliationWindowStart: startedAt,
+            reconciliationWindowEnd: now().toISOString(),
+            expectedActionIds: [grant.actionId],
+            observedTargetEvents: auditEvents,
+            matchedEvents: matching.map((event) => event.targetEventId),
+            unmatchedTargetEvents,
+            unmatchedReceipts: matching.length ? [] : [grant.actionId],
+            duplicateMatches,
+            result: reconciliationResult,
+            limitations: ["Reconciliation covers the dedicated sandbox credential and declared time window only."],
+            collectorIdentityId: options.runtime.runtimeIdentityId,
+            collectedAt: now().toISOString(),
+        }, options.runtime.signer);
+        const eventCheckpoint = signRuntimeObject({
+            protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+            objectType: "EventChainCheckpoint",
+            signatureContext: EVENT_CHECKPOINT_CONTEXT,
+            actionId: grant.actionId,
+            executionSessionId,
+            eventCount: events.length,
+            firstEventHash: events[0].payloadSha256,
+            finalEventHash: events.at(-1).payloadSha256,
+            completedAt: now().toISOString(),
+        }, options.runtime.signer);
+        return {
+            protocolVersion: BROWSER_ENFORCEMENT_PROTOCOL,
+            executionGrant: options.grant,
+            grantStatus: "CONSUMED",
+            runtimeClaim,
+            executionSession: session,
+            credentialLease,
+            events,
+            eventCheckpoint,
+            outcomeAttestation,
+            reconciliationReport,
+            finalParametersDigest,
+            detectedBypass: reconciliationResult !== "PASSED",
+            execution,
+        };
+    }
+    catch (error) {
+        try {
+            await append("EXECUTION_SESSION_FAILED", { reasonCode: error instanceof Error ? error.message.slice(0, 200) : "EXECUTION_FAILED" });
+        }
+        finally {
+            if (!leaseRevoked)
+                await revokeCredentialLease();
+        }
+        throw error;
+    }
+}
+export function verifyHostedExecutionGrant(grant, issuerKeys, at = new Date(), clockSkewMs = 30_000) {
+    const payload = grant.payload;
+    if (payload.protocolVersion !== BROWSER_ENFORCEMENT_PROTOCOL || payload.objectType !== "ExecutionGrant" || payload.signatureContext !== EXECUTION_GRANT_CONTEXT)
+        throw new Error("UNSUPPORTED_PROTOCOL_VERSION");
+    if (payload.maxUses !== 1 || grant.payloadSha256 !== sha256(canonicalJson(payload)))
+        throw new Error("EXECUTION_GRANT_DIGEST_MISMATCH");
+    const publicKey = issuerKeys[payload.issuerKeyId];
+    if (!publicKey)
+        throw new Error("EXECUTION_GRANT_UNKNOWN_ISSUER");
+    const bytes = Buffer.from(canonicalJson(payload));
+    if (grant.attestation.payloadSha256 !== sha256(bytes))
+        throw new Error("EXECUTION_GRANT_INVALID_SIGNATURE");
+    let valid = false;
+    try {
+        valid = verify(null, bytes, createPublicKey(publicKey), Buffer.from(grant.attestation.signature, "base64url"));
+    }
+    catch {
+        valid = false;
+    }
+    if (!valid)
+        throw new Error("EXECUTION_GRANT_INVALID_SIGNATURE");
+    if (at.getTime() + clockSkewMs < Date.parse(payload.notBefore))
+        throw new Error("EXECUTION_GRANT_NOT_YET_VALID");
+    if (at.getTime() - clockSkewMs >= Date.parse(payload.expiresAt))
+        throw new Error("EXECUTION_GRANT_EXPIRED");
+}
+export function signRuntimeObject(payload, signer) {
+    const payloadSha256 = sha256(canonicalJson(payload));
+    return { payload, payloadSha256, signature: signDigest(payloadSha256, signer) };
+}
+function assertBindings(options) {
+    const grant = options.grant.payload;
+    if (grant.expectedRuntimeIdentityId !== options.runtime.runtimeIdentityId)
+        throw new Error("RUNTIME_IDENTITY_MISMATCH");
+    if (grant.actionId !== options.action.id || grant.actionIntentDigest !== options.actionIntentDigest)
+        throw new Error("ACTION_DIGEST_MISMATCH");
+    if (grant.agentBuildDigest !== options.agentBuildDigest)
+        throw new Error("AGENT_BUILD_MISMATCH");
+    if (grant.adapterId !== options.adapter.name || grant.targetAudience !== options.action.targetSystem)
+        throw new Error("ADAPTER_MISMATCH");
+    if (!versionSatisfiesConstraint(options.adapterVersion, grant.adapterVersionConstraint))
+        throw new Error("ADAPTER_VERSION_MISMATCH");
+    if (!options.action.targetUrl || !grant.allowedOrigins.includes(normalizedOrigin(options.action.targetUrl)))
+        throw new Error("TARGET_ORIGIN_MISMATCH");
+    if (!options.adapter.control.allowedActionTypes.includes(options.action.actionType) || !options.adapter.control.allowedTargetSystems.includes(options.action.targetSystem))
+        throw new Error("ADAPTER_SCOPE_MISMATCH");
+    if (sha256(canonicalJson(options.outcomePredicate)) !== grant.outcomePredicateDigest)
+        throw new Error("OUTCOME_PREDICATE_MISMATCH");
+}
+function normalizedOrigin(value) {
+    try {
+        return new URL(value).origin;
+    }
+    catch {
+        throw new Error("TARGET_ORIGIN_INVALID");
+    }
+}
+function versionSatisfiesConstraint(version, constraint) {
+    const parsed = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    if (!parsed)
+        return false;
+    const exact = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(constraint);
+    if (exact)
+        return parsed.slice(1).join(".") === exact.slice(1).join(".");
+    const compatible = /^\^v?(\d+)\.(\d+)\.(\d+)$/.exec(constraint);
+    if (!compatible)
+        return false;
+    const [major, minor, patch] = parsed.slice(1).map(Number);
+    const [requiredMajor, requiredMinor, requiredPatch] = compatible.slice(1).map(Number);
+    return major === requiredMajor && (minor > requiredMinor || (minor === requiredMinor && patch >= requiredPatch));
+}
+function redactAndBound(value) {
+    const sensitive = /authorization|cookie|password|secret|token|credential|api.?key/i;
+    const redact = (input, depth) => {
+        if (depth > 8)
+            return "[TRUNCATED]";
+        if (Array.isArray(input))
+            return input.slice(0, 100).map((item) => redact(item, depth + 1));
+        if (input && typeof input === "object")
+            return Object.fromEntries(Object.entries(input).slice(0, 100).map(([key, child]) => [key, sensitive.test(key) ? "[REDACTED]" : redact(child, depth + 1)]));
+        if (typeof input === "string")
+            return input.slice(0, 2_048);
+        return input;
+    };
+    const output = redact(value, 0);
+    if (Buffer.byteLength(canonicalJson(output)) > 32_768)
+        throw new Error("EXECUTION_EVENT_TOO_LARGE");
+    return output;
+}
+function subsetMatches(expected, observed) {
+    return Object.entries(expected).every(([key, value]) => canonicalJson(observed[key]) === canonicalJson(value));
+}

package/dist/vendor/onegent-runtime/controlled-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { ControlledActionAdapter, IndependentOutcomeProbe } from "./trust-types.js";
+export declare function createControlledActionAdapter(adapter: ControlledActionAdapter): ControlledActionAdapter;
+export declare function isRegisteredControlledActionAdapter(adapter: ControlledActionAdapter): boolean;
+export declare function createIndependentOutcomeProbe(probe: IndependentOutcomeProbe): IndependentOutcomeProbe;
+export declare function isRegisteredIndependentOutcomeProbe(probe: IndependentOutcomeProbe): boolean;
+//# sourceMappingURL=controlled-adapter.d.ts.map

package/dist/vendor/onegent-runtime/controlled-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlled-adapter.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/controlled-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAKzF,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,uBAAuB,GAAG,uBAAuB,CAYvG;AAED,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAE7F;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,uBAAuB,GAAG,uBAAuB,CAKrG;AAED,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAE3F"}

package/dist/vendor/onegent-runtime/controlled-adapter.js

@@ -0,0 +1,40 @@
+const registeredAdapters = new WeakSet();
+const registeredProbes = new WeakSet();
+export function createControlledActionAdapter(adapter) {
+    validateBoundary(adapter);
+    const controlled = Object.freeze({
+        ...adapter,
+        control: Object.freeze({
+            ...adapter.control,
+            allowedActionTypes: Object.freeze([...adapter.control.allowedActionTypes]),
+            allowedTargetSystems: Object.freeze([...adapter.control.allowedTargetSystems]),
+        }),
+    });
+    registeredAdapters.add(controlled);
+    return controlled;
+}
+export function isRegisteredControlledActionAdapter(adapter) {
+    return registeredAdapters.has(adapter);
+}
+export function createIndependentOutcomeProbe(probe) {
+    if (!probe.name?.trim() || probe.independent !== true)
+        throw new Error("Independent outcome probe name and boundary are required.");
+    const controlled = Object.freeze({ ...probe, independent: true });
+    registeredProbes.add(controlled);
+    return controlled;
+}
+export function isRegisteredIndependentOutcomeProbe(probe) {
+    return registeredProbes.has(probe);
+}
+function validateBoundary(adapter) {
+    if (!adapter.name?.trim())
+        throw new Error("Controlled adapter name is required.");
+    const control = adapter.control;
+    if (!control || control.mode !== "agentcert_gateway" || control.credentials !== "gateway_managed"
+        || control.bypassPrevention !== "credentials_unavailable_to_agent") {
+        throw new Error(`Adapter ${adapter.name} does not provide the required Witnora credential-isolated gateway boundary.`);
+    }
+    if (!control.allowedActionTypes.length || !control.allowedTargetSystems.length) {
+        throw new Error(`Adapter ${adapter.name} must declare bounded action types and target systems.`);
+    }
+}

package/dist/vendor/onegent-runtime/mock-procurement.d.ts

@@ -0,0 +1,6 @@
+import type { ActionIntent, MockPurchaseOrder } from "./types.js";
+export declare const PROCUREMENT_DEMO_PO_ID = "PO-DEMO-4850";
+export declare function createProcurementDemoPurchaseOrder(): MockPurchaseOrder;
+export declare function getPurchaseOrder(id: string): MockPurchaseOrder | undefined;
+export declare function submitMockPurchaseOrder(action: ActionIntent): MockPurchaseOrder;
+//# sourceMappingURL=mock-procurement.d.ts.map

package/dist/vendor/onegent-runtime/mock-procurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-procurement.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/mock-procurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGlE,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAErD,wBAAgB,kCAAkC,IAAI,iBAAiB,CActE;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAE1E;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,YAAY,GAAG,iBAAiB,CAc/E"}

package/dist/vendor/onegent-runtime/mock-procurement.js

@@ -0,0 +1,33 @@
+import { nowIso, store } from "./store.js";
+export const PROCUREMENT_DEMO_PO_ID = "PO-DEMO-4850";
+export function createProcurementDemoPurchaseOrder() {
+    const purchaseOrder = {
+        id: PROCUREMENT_DEMO_PO_ID,
+        vendor: "Acme Industrial Supply",
+        amount: 4_850,
+        currency: "USD",
+        status: "DRAFT",
+        vendorApproved: true,
+        lineItem: "Replacement conveyor motor assembly",
+        lastUpdatedAt: nowIso(),
+    };
+    store.purchaseOrders.set(purchaseOrder.id, purchaseOrder);
+    return purchaseOrder;
+}
+export function getPurchaseOrder(id) {
+    return store.purchaseOrders.get(id);
+}
+export function submitMockPurchaseOrder(action) {
+    const purchaseOrder = store.purchaseOrders.get(action.businessObjectId);
+    if (!purchaseOrder) {
+        throw new Error(`Mock purchase order ${action.businessObjectId} was not found.`);
+    }
+    const updated = {
+        ...purchaseOrder,
+        status: "SUBMITTED",
+        lastUpdatedAt: nowIso(),
+        actionIntentId: action.id,
+    };
+    store.purchaseOrders.set(updated.id, updated);
+    return updated;
+}

package/dist/vendor/onegent-runtime/policies.d.ts

@@ -0,0 +1,6 @@
+import type { ActionIntent, PolicyEvaluation, PolicyRule, RiskAssessment } from "./types.js";
+export declare const DEFAULT_POLICY_RULES: PolicyRule[];
+export declare function evaluatePolicy(action: ActionIntent, risk: RiskAssessment, policyRules?: PolicyRule[]): PolicyEvaluation;
+export declare function getPolicyRules(ids: string[], policyRules?: PolicyRule[]): PolicyRule[];
+export declare function matchesRule(action: ActionIntent, rule: PolicyRule): boolean;
+//# sourceMappingURL=policies.d.ts.map

package/dist/vendor/onegent-runtime/policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/policies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAmB,gBAAgB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE9G,eAAO,MAAM,oBAAoB,EAAE,UAAU,EAmC5C,CAAC;AAEF,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,cAAc,EACpB,WAAW,GAAE,UAAU,EAAyB,GAC/C,gBAAgB,CA6ClB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,WAAW,GAAE,UAAU,EAAyB,GAAG,UAAU,EAAE,CAG5G;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAQ3E"}

package/dist/vendor/onegent-runtime/policies.js

@@ -0,0 +1,109 @@
+export const DEFAULT_POLICY_RULES = [
+    {
+        id: "po-over-1000-requires-approval",
+        name: "Purchase orders over $1,000 require approval",
+        description: "High-value purchase order submissions must be reviewed before mock execution.",
+        actionTypes: ["SUBMIT"],
+        effect: "REQUIRE_APPROVAL",
+        enabled: true,
+        conditions: [{ field: "amount", operator: "greaterThan", value: 1_000 }],
+    },
+    {
+        id: "payment-actions-require-approval",
+        name: "Payment actions require approval",
+        description: "The demo runtime never executes real payments and requires approval for mock payment actions.",
+        actionTypes: ["PAY"],
+        effect: "REQUIRE_APPROVAL",
+        enabled: true,
+    },
+    {
+        id: "external-send-requires-approval",
+        name: "External send actions require approval",
+        description: "Outbound communications to non-demo recipients require approval.",
+        actionTypes: ["SEND"],
+        effect: "REQUIRE_APPROVAL",
+        enabled: true,
+    },
+    {
+        id: "production-actions-blocked-in-demo",
+        name: "Production actions are blocked in demo mode",
+        description: "This package is local-only and will not perform production actions.",
+        actionTypes: ["SUBMIT", "PAY", "SEND", "UPDATE"],
+        effect: "BLOCK",
+        enabled: true,
+        conditions: [{ field: "environment", operator: "equals", value: "production" }],
+    },
+];
+export function evaluatePolicy(action, risk, policyRules = DEFAULT_POLICY_RULES) {
+    if (action.environment === "production") {
+        const productionBlock = policyRules.find((rule) => rule.id === "production-actions-blocked-in-demo") ??
+            DEFAULT_POLICY_RULES.find((rule) => rule.id === "production-actions-blocked-in-demo");
+        return {
+            effect: "BLOCK",
+            triggeredPolicies: productionBlock ? [productionBlock.id] : [],
+            reasons: [productionBlock?.description ?? "Production actions are blocked in this local demo runtime."],
+            requiresHumanApproval: false,
+            blocked: true,
+        };
+    }
+    const triggeredRules = policyRules.filter((rule) => matchesRule(action, rule));
+    const blockRules = triggeredRules.filter((rule) => rule.effect === "BLOCK");
+    if (blockRules.length > 0) {
+        return {
+            effect: "BLOCK",
+            triggeredPolicies: blockRules.map((rule) => rule.id),
+            reasons: blockRules.map((rule) => rule.description),
+            requiresHumanApproval: false,
+            blocked: true,
+        };
+    }
+    const approvalRules = triggeredRules.filter((rule) => rule.effect === "REQUIRE_APPROVAL");
+    if (approvalRules.length > 0) {
+        return {
+            effect: "REQUIRE_APPROVAL",
+            triggeredPolicies: approvalRules.map((rule) => rule.id),
+            reasons: approvalRules.map((rule) => rule.description),
+            requiresHumanApproval: true,
+            blocked: false,
+        };
+    }
+    return {
+        effect: "ALLOW",
+        triggeredPolicies: triggeredRules.map((rule) => rule.id),
+        reasons: risk.reasons,
+        requiresHumanApproval: false,
+        blocked: false,
+    };
+}
+export function getPolicyRules(ids, policyRules = DEFAULT_POLICY_RULES) {
+    const idSet = new Set(ids);
+    return policyRules.filter((rule) => idSet.has(rule.id));
+}
+export function matchesRule(action, rule) {
+    if (!rule.enabled || !rule.actionTypes.includes(action.actionType)) {
+        return false;
+    }
+    if (!rule.conditions || rule.conditions.length === 0) {
+        return true;
+    }
+    return rule.conditions.every((condition) => matchesCondition(action, condition));
+}
+function matchesCondition(action, condition) {
+    const actual = action[condition.field];
+    switch (condition.operator) {
+        case "equals":
+            return actual === condition.value;
+        case "notEquals":
+            return actual !== condition.value;
+        case "greaterThan":
+            return typeof actual === "number" && typeof condition.value === "number" && actual > condition.value;
+        case "greaterThanOrEqual":
+            return typeof actual === "number" && typeof condition.value === "number" && actual >= condition.value;
+        case "lessThan":
+            return typeof actual === "number" && typeof condition.value === "number" && actual < condition.value;
+        case "lessThanOrEqual":
+            return typeof actual === "number" && typeof condition.value === "number" && actual <= condition.value;
+        case "includes":
+            return typeof actual === "string" && typeof condition.value === "string" && actual.includes(condition.value);
+    }
+}

package/dist/vendor/onegent-runtime/risk.d.ts

@@ -0,0 +1,3 @@
+import type { ActionIntent, RiskAssessment } from "./types.js";
+export declare function assessRisk(action: ActionIntent): RiskAssessment;
+//# sourceMappingURL=risk.d.ts.map

package/dist/vendor/onegent-runtime/risk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"risk.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/risk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAa,MAAM,YAAY,CAAC;AAK1E,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,CAsD/D"}

package/dist/vendor/onegent-runtime/risk.js

@@ -0,0 +1,54 @@
+import { nextId, nowIso } from "./store.js";
+const PURCHASE_ORDER_APPROVAL_THRESHOLD = 1_000;
+export function assessRisk(action) {
+    const reasons = [];
+    const triggeredPolicies = [];
+    let riskLevel = "LOW";
+    let riskScore = 20;
+    if (action.actionType === "PAY") {
+        riskLevel = "HIGH";
+        riskScore = 85;
+        reasons.push("Payment actions can move money and require human approval in the demo runtime.");
+        triggeredPolicies.push("payment-actions-require-approval");
+    }
+    if (action.actionType === "SEND" && action.recipient && !action.recipient.endsWith("@example.local")) {
+        riskLevel = maxRisk(riskLevel, "HIGH");
+        riskScore = Math.max(riskScore, 75);
+        reasons.push("External send actions can disclose business data and require human approval.");
+        triggeredPolicies.push("external-send-requires-approval");
+    }
+    if (action.actionType === "SUBMIT" && (action.amount ?? 0) > PURCHASE_ORDER_APPROVAL_THRESHOLD) {
+        riskLevel = maxRisk(riskLevel, "HIGH");
+        riskScore = Math.max(riskScore, 80);
+        reasons.push("Purchase orders over $1,000 require human approval.");
+        triggeredPolicies.push("po-over-1000-requires-approval");
+    }
+    if (action.actionType === "UPDATE" && action.fieldsChanged.length > 0) {
+        riskLevel = maxRisk(riskLevel, "MEDIUM");
+        riskScore = Math.max(riskScore, 45);
+        reasons.push("Update actions modify business records and require verification.");
+    }
+    if (action.environment === "production") {
+        riskLevel = maxRisk(riskLevel, "CRITICAL");
+        riskScore = Math.max(riskScore, 95);
+        reasons.push("Production actions are blocked in this local demo runtime.");
+        triggeredPolicies.push("production-actions-blocked-in-demo");
+    }
+    if (reasons.length === 0) {
+        reasons.push("No high-risk demo policy matched this action.");
+    }
+    return {
+        id: nextId("risk"),
+        actionIntentId: action.id,
+        riskLevel,
+        riskScore,
+        reasons,
+        triggeredPolicies,
+        requiresHumanApproval: riskLevel === "HIGH" || riskLevel === "CRITICAL",
+        createdAt: nowIso(),
+    };
+}
+function maxRisk(left, right) {
+    const order = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
+    return order[Math.max(order.indexOf(left), order.indexOf(right))];
+}