@pipeline-builder/api-core 4.1.20 → 4.1.21

package/lib/types/remote-audit-actions.js

@@ -0,0 +1,305 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The remote (non-platform) audit ACTION VOCABULARY.
+ *
+ * Kept apart from the client that ships the events (`services/remote-audit-client.ts`)
+ * because it is an allow-list, not machinery: it is the thing a reviewer reads
+ * end to end when deciding whether a service may emit a given action, and it is
+ * what platform's ingest validates against.
+ */
+/**
+ * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to
+ * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`
+ * is derived from it, so the type and the runtime allow-list can never drift.
+ *
+ * SECURITY: platform's ingest validates `action` against this subset (via
+ * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a
+ * `service:*` token must not be able to forge platform-authority events
+ * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
+ * this list free of any platform-only action.
+ */
+export const REMOTE_AUDIT_ACTIONS = [
+    'plugin.build.completed',
+    'plugin.build.failed',
+    'plugin.build.timeout',
+    // A version persisted UNSCANNED because the build-time scan could not run and
+    // the operator escape hatch `PLUGIN_ALLOW_UNSCANNED` is on (without it the
+    // build fails `IMAGE_SCAN_UNAVAILABLE`). `details` carry name/version/digest.
+    'plugin.scan.skipped',
+    // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /
+    // publishing surface that builds already audit's counterpart: registry delete,
+    // source upload, and deploy-to-cluster. `targetId` is the plugin id.
+    'plugin.delete',
+    'plugin.restore',
+    // Manual purge: permanent hard-delete of a soft-deleted plugin tombstone on
+    // demand (finalizes what the retention sweep would otherwise do later).
+    'plugin.purge',
+    'plugin.update',
+    'plugin.upload',
+    'plugin.deploy',
+    // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all
+    // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.
+    'plugin.bulk.update',
+    'plugin.bulk.delete',
+    'plugin.dlq.purge',
+    // Build re-runs from the queue-triage surface: re-enqueue a FAILED build
+    // (`plugin.build.retry`) or a dead-lettered one (`plugin.dlq.replay`). Both
+    // re-run an image build + plugin persist on the caller's authority, so they
+    // are audited mutations; `affectedOrgId` carries the job's owning org.
+    'plugin.build.retry',
+    'plugin.dlq.replay',
+    // Pipeline mutations — emitted by api/pipeline's route handlers
+    // (create/update/delete + CodePipeline execution trigger/cancel) and
+    // posted to platform's `POST /audit/events` ingest.
+    'pipeline.create',
+    'pipeline.update',
+    'pipeline.delete',
+    'pipeline.restore',
+    // Manual purge: permanent hard-delete of a soft-deleted pipeline /
+    // pipeline_template tombstone on demand (finalizes what the retention sweep
+    // would otherwise do later). `targetId` is the purged id.
+    'pipeline.purge',
+    'pipeline_template.create',
+    'pipeline_template.update',
+    'pipeline_template.delete',
+    'pipeline_template.restore',
+    'pipeline_template.purge',
+    'pipeline.execution.start',
+    'pipeline.execution.cancel',
+    // CodePipeline ARN-registry config (api/pipeline registry route) — registering /
+    // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).
+    'pipeline.registry.register',
+    'pipeline.registry.deregister',
+    // Quota administration (api/quota) — a superadmin resetting an org's usage
+    // counter or editing its tier limits. `affectedOrgId` is the org changed;
+    // `details` carries the quotaType + old/new value.
+    'quota.reset',
+    'quota.limit.update',
+    // A superadmin deleting an org's entire quota document.
+    'quota.delete',
+    // Compliance administration (api/compliance) — the enforcement-posture surface.
+    // Approving/revoking an exemption, toggling/authoring/deleting a rule,
+    // authoring/deleting a policy, managing scan schedules, applying a template,
+    // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.
+    'compliance.exemption.approve',
+    'compliance.exemption.revoke',
+    'compliance.rule.toggle',
+    'compliance.rule.create',
+    'compliance.rule.update',
+    'compliance.rule.delete',
+    'compliance.rule.restore',
+    // Manual on-demand hard-delete (PURGE) of a soft-deleted rule/policy tombstone —
+    // the caller-initiated counterpart to the retention sweep's auto-purge. Destroys
+    // the tombstone permanently, so it carries the durable, tamper-evident trail.
+    'compliance.rule.purge',
+    'compliance.policy.create',
+    'compliance.policy.update',
+    'compliance.policy.delete',
+    'compliance.policy.restore',
+    'compliance.policy.purge',
+    'compliance.scan-schedule.create',
+    'compliance.scan-schedule.update',
+    'compliance.scan-schedule.delete',
+    'compliance.template.apply',
+    // Launching an org-wide re-evaluation (the counterpart to `.cancel`) — it
+    // persists a scan and can block entities that passed before.
+    'compliance.scan.create',
+    'compliance.scan.cancel',
+    // Per-org compliance notification settings: recipients + the outbound webhook
+    // URL/secret. Bearer-equivalent config that redirects violation notices, so a
+    // change carries the durable trail (never the secret itself).
+    'compliance.notification-preference.update',
+    // Image-registry destructive ops (api/image-registry) — garbage-collection
+    // sweeps and explicit image/tag deletes.
+    'registry.gc',
+    'registry.image.delete',
+    // Cross-repo tag/image copy (api/image-registry POST /api/images/copy). A
+    // cross-tenant copy moves data across customer boundaries, so it needs the
+    // durable, tamper-evident trail — not just the Loki operator line.
+    'registry.image.copy',
+    // A plugin image signed + SBOM-attested by the platform's plugin-signing key
+    // (api/image-registry POST /internal/plugin-signatures, called by the plugin
+    // build worker). The key is what synth trusts, so every use is on the trail.
+    'registry.image.sign',
+    // Messaging (api/message) — admin BROADCAST announcements + destructive
+    // deletes. 1:1 user messages are intentionally NOT audited (noise + they would
+    // pull private content into the trail). `details` carry metadata only
+    // (subject/type/scope), NEVER message body content.
+    'message.announcement.create',
+    'message.delete',
+    'message.restore',
+    // Manual on-demand PURGE (permanent hard-delete) of an already-soft-deleted
+    // message tombstone — the destructive finalizer the retention sweep would
+    // otherwise perform at the purge deadline. `details` carry metadata only.
+    'message.purge',
+    // Billing (api/billing) — subscription + entitlement mutations, mirrored to the
+    // central audit trail (these also write to the service-local billing_events
+    // collection). `details` carry plan/tier/addon ids only — never card/payment
+    // secrets or an AWS account id.
+    // Subscription lifecycle a CUSTOMER drives (the admin counterpart is
+    // `billing.tier.override`): self-serve create (direct or Marketplace claim),
+    // plan/interval change, cancel-at-period-end, undo-cancel, cascade delete.
+    'billing.subscription.create',
+    'billing.subscription.update',
+    'billing.subscription.reactivate',
+    'billing.subscription.cancel',
+    'billing.subscription.delete',
+    'billing.tier.override',
+    // Operator-only reseed of the invoice ledger from the payment provider's
+    // history (POST /billing/admin/backfill) — mutates finance data fleet-wide.
+    'billing.addon.add',
+    'billing.addon.remove',
+    // System-initiated removal of a tier-included add-on on a plan upgrade (the
+    // account's new tier now bundles the feature) — distinct from a user-initiated
+    // `remove` so finance can tell an auto-prune from a customer action.
+    'billing.addon.prune',
+    // Discounts (docs/billing-discounts.md) — mint/issue/apply/remove/revoke of a
+    // price coupon or usage credit. `details` carry the discount id + kind/value
+    // only, never the opaque token or signing key.
+    'billing.discount.generate',
+    'billing.discount.issue',
+    'billing.discount.apply',
+    'billing.discount.remove',
+    'billing.discount.revoke',
+    // Promotions (docs/billing-discounts.md#promotions) — rule-driven auto-grant
+    // campaigns. `details` carry the promotion id + cents/event only.
+    'billing.promotion.create',
+    'billing.promotion.update',
+    'billing.promotion.revoke',
+    'billing.promotion.grant',
+    'billing.promotion.activate',
+    // Usage-credit realization — a customer/compliance-visible record of credit
+    // movement: `consumed` (Marketplace metered drawdown), `exhausted` (balance hit
+    // zero), and a combo ending. `details` carry cents/ids only, no payment secrets.
+    'billing.credit.consumed',
+    'billing.credit.exhausted',
+    'billing.combo.expired',
+    // Reporting (api/reporting) — the three reporting mutations whose effect
+    // outlives a request log: the per-org correlation-window config write, a
+    // post-deploy outcome marker (it moves the org's DORA CFR/MTTR), and the
+    // inbound billing→reporting retention-entitlement sync (a retention cut is a
+    // data-destroying change applied by the next sweep). `details` carry the
+    // settings/outcome values only.
+    'reporting.settings.update',
+    'reporting.deployment.outcome',
+    'reporting.retention.sync',
+    // Denied authorization attempt — emitted best-effort by the shared
+    // `requirePermission` / `requireSystemAdmin` gate when a state-changing
+    // (non-GET) request is rejected, so probing/escalation attempts are visible
+    // rather than invisible. `details` carries the required permission + path;
+    // `outcome` is 'failure'.
+    'authz.denied',
+    // "Ask" assistant activity — visibility into what the assistant did on a user's
+    // behalf. `ask.query` is a read-only how-to turn; `ask.agent.turn` is a tool-calling
+    // turn. `details` carry SAFE METADATA ONLY (tools used, proposal kinds, query
+    // length, outcome), never the raw query text.
+    'ask.query',
+    'ask.agent.turn',
+    // Plugin ecosystem (docs/runbooks/ecosystem-moderation.md). Governance actions
+    // are recorded with `orgId` = the system org; `affectedOrgId` is the
+    // publisher's org (listing/version/review/advisory/publisher moderation) or
+    // the installing org (installs + policy). Anonymous submissions use the
+    // `ANONYMOUS_ACTOR_ID` actor with `details.submissionId`. `details` carry ids,
+    // versions, digests, tier, state and reason codes only — never review bodies,
+    // README content, secrets or emails.
+    // Publishers.
+    'publisher.create',
+    'publisher.update',
+    'publisher.terms.accept',
+    'publisher.verify.request',
+    'publisher.verify.approve',
+    'publisher.verify.reject',
+    'publisher.tier.change',
+    'publisher.suspend',
+    'publisher.unsuspend',
+    'publisher.transfer.request',
+    'publisher.transfer.accept',
+    'publisher.transfer.decline',
+    'publisher.transfer.approve',
+    'publisher.transfer.reject',
+    'publisher.profile-change.approve',
+    'publisher.profile-change.reject',
+    // Publish requests (tenant → system org). `details.kind` names the request.
+    'plugin.request.submit',
+    'plugin.request.withdraw',
+    'plugin.request.approve',
+    'plugin.request.second-approve',
+    'plugin.request.reject',
+    'plugin.request.auto-approve',
+    // Listings and versions (system org, except the tenant pause).
+    'plugin.listing.publish',
+    'plugin.listing.unlist',
+    'plugin.listing.update',
+    'plugin.listing.state.change',
+    'plugin.listing.pause',
+    'plugin.listing.unpause',
+    'plugin.version.pause',
+    'plugin.version.yank',
+    'plugin.version.unyank',
+    'plugin.version.deprecate',
+    'plugin.collection.update',
+    // Ecosystem configuration (system org).
+    'ecosystem.auto-approval-rule.create',
+    'ecosystem.auto-approval-rule.update',
+    'ecosystem.auto-approval-rule.delete',
+    'ecosystem.reserved-name.update',
+    'ecosystem.sla.update',
+    // Public registry namespace (`public/*`): copy + sign + attest on publish,
+    // the tier-change/suspension re-sign job, tag removal on yank/takedown, and
+    // the retention sweep.
+    'registry.image.publish',
+    'registry.image.resign',
+    'registry.image.yank',
+    'registry.image.gc',
+    // Installs and the installing org's consumption policy (org-local).
+    'plugin.install.request',
+    'plugin.install.approve',
+    'plugin.install.deny',
+    'plugin.install.create',
+    'plugin.install.upgrade',
+    // A member's request to change an install past what they may do alone, and its decision.
+    'plugin.install.change-request',
+    'plugin.install.change-approve',
+    'plugin.install.change-reject',
+    'plugin.install.remove',
+    'org.plugin-install-policy.update',
+    // Reviews and replies.
+    'plugin.review.create',
+    'plugin.review.update',
+    'plugin.review.delete',
+    'plugin.review.report',
+    'plugin.review.hold',
+    'plugin.review.release',
+    'plugin.review.remove',
+    'plugin.review.anonymize',
+    'plugin.review.reply.create',
+    'plugin.review.reply.update',
+    'plugin.review.reply.delete',
+    // Anonymous submissions.
+    'plugin.submission.create',
+    'plugin.submission.verify',
+    'plugin.submission.gate-fail',
+    'plugin.submission.approve',
+    'plugin.submission.reject',
+    'plugin.submission.claim',
+    'plugin.submission.expire',
+    // Security advisories (publish/withdraw are system-org only; update = a
+    // moderator editing a draft before it is published).
+    'plugin.advisory.create',
+    'plugin.advisory.update',
+    'plugin.advisory.publish',
+    'plugin.advisory.withdraw',
+    // Per-org plugin security notifications (plugin scan gates): the settings
+    // (recipients, digest, webhook, external address — changed field names and
+    // the webhook host only, never the secret or the address), an external
+    // address confirmed through its emailed single-use link, and a test send.
+    'plugin.security_notifications.update',
+    'plugin.security_notifications.external_email.verify',
+    'plugin.security_notifications.test',
+];
+/** Whether `value` is an action a remote service may emit (the ingest allow-list). */
+export function isRemoteAuditAction(value) {
+    return REMOTE_AUDIT_ACTIONS.includes(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-actions.js","sourceRoot":"","sources":["../../src/types/remote-audit-actions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The remote (non-platform) audit ACTION VOCABULARY.\n *\n * Kept apart from the client that ships the events (`services/remote-audit-client.ts`)\n * because it is an allow-list, not machinery: it is the thing a reviewer reads\n * end to end when deciding whether a service may emit a given action, and it is\n * what platform's ingest validates against.\n */\n\n\n/**\n * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to\n * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`\n * is derived from it, so the type and the runtime allow-list can never drift.\n *\n * SECURITY: platform's ingest validates `action` against this subset (via\n * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a\n * `service:*` token must not be able to forge platform-authority events\n * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep\n * this list free of any platform-only action.\n */\nexport const REMOTE_AUDIT_ACTIONS = [\n  'plugin.build.completed',\n  'plugin.build.failed',\n  'plugin.build.timeout',\n  // A version persisted UNSCANNED because the build-time scan could not run and\n  // the operator escape hatch `PLUGIN_ALLOW_UNSCANNED` is on (without it the\n  // build fails `IMAGE_SCAN_UNAVAILABLE`). `details` carry name/version/digest.\n  'plugin.scan.skipped',\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  'plugin.delete',\n  'plugin.restore',\n  // Manual purge: permanent hard-delete of a soft-deleted plugin tombstone on\n  // demand (finalizes what the retention sweep would otherwise do later).\n  'plugin.purge',\n  'plugin.update',\n  'plugin.upload',\n  'plugin.deploy',\n  // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all\n  // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.\n  'plugin.bulk.update',\n  'plugin.bulk.delete',\n  'plugin.dlq.purge',\n  // Build re-runs from the queue-triage surface: re-enqueue a FAILED build\n  // (`plugin.build.retry`) or a dead-lettered one (`plugin.dlq.replay`). Both\n  // re-run an image build + plugin persist on the caller's authority, so they\n  // are audited mutations; `affectedOrgId` carries the job's owning org.\n  'plugin.build.retry',\n  'plugin.dlq.replay',\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  'pipeline.create',\n  'pipeline.update',\n  'pipeline.delete',\n  'pipeline.restore',\n  // Manual purge: permanent hard-delete of a soft-deleted pipeline /\n  // pipeline_template tombstone on demand (finalizes what the retention sweep\n  // would otherwise do later). `targetId` is the purged id.\n  'pipeline.purge',\n  'pipeline_template.create',\n  'pipeline_template.update',\n  'pipeline_template.delete',\n  'pipeline_template.restore',\n  'pipeline_template.purge',\n  'pipeline.execution.start',\n  'pipeline.execution.cancel',\n  // CodePipeline ARN-registry config (api/pipeline registry route) — registering /\n  // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).\n  'pipeline.registry.register',\n  'pipeline.registry.deregister',\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  'quota.reset',\n  'quota.limit.update',\n  // A superadmin deleting an org's entire quota document.\n  'quota.delete',\n  // Compliance administration (api/compliance) — the enforcement-posture surface.\n  // Approving/revoking an exemption, toggling/authoring/deleting a rule,\n  // authoring/deleting a policy, managing scan schedules, applying a template,\n  // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.\n  'compliance.exemption.approve',\n  'compliance.exemption.revoke',\n  'compliance.rule.toggle',\n  'compliance.rule.create',\n  'compliance.rule.update',\n  'compliance.rule.delete',\n  'compliance.rule.restore',\n  // Manual on-demand hard-delete (PURGE) of a soft-deleted rule/policy tombstone —\n  // the caller-initiated counterpart to the retention sweep's auto-purge. Destroys\n  // the tombstone permanently, so it carries the durable, tamper-evident trail.\n  'compliance.rule.purge',\n  'compliance.policy.create',\n  'compliance.policy.update',\n  'compliance.policy.delete',\n  'compliance.policy.restore',\n  'compliance.policy.purge',\n  'compliance.scan-schedule.create',\n  'compliance.scan-schedule.update',\n  'compliance.scan-schedule.delete',\n  'compliance.template.apply',\n  // Launching an org-wide re-evaluation (the counterpart to `.cancel`) — it\n  // persists a scan and can block entities that passed before.\n  'compliance.scan.create',\n  'compliance.scan.cancel',\n  // Per-org compliance notification settings: recipients + the outbound webhook\n  // URL/secret. Bearer-equivalent config that redirects violation notices, so a\n  // change carries the durable trail (never the secret itself).\n  'compliance.notification-preference.update',\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes.\n  'registry.gc',\n  'registry.image.delete',\n  // Cross-repo tag/image copy (api/image-registry POST /api/images/copy). A\n  // cross-tenant copy moves data across customer boundaries, so it needs the\n  // durable, tamper-evident trail — not just the Loki operator line.\n  'registry.image.copy',\n  // A plugin image signed + SBOM-attested by the platform's plugin-signing key\n  // (api/image-registry POST /internal/plugin-signatures, called by the plugin\n  // build worker). The key is what synth trusts, so every use is on the trail.\n  'registry.image.sign',\n  // Messaging (api/message) — admin BROADCAST announcements + destructive\n  // deletes. 1:1 user messages are intentionally NOT audited (noise + they would\n  // pull private content into the trail). `details` carry metadata only\n  // (subject/type/scope), NEVER message body content.\n  'message.announcement.create',\n  'message.delete',\n  'message.restore',\n  // Manual on-demand PURGE (permanent hard-delete) of an already-soft-deleted\n  // message tombstone — the destructive finalizer the retention sweep would\n  // otherwise perform at the purge deadline. `details` carry metadata only.\n  'message.purge',\n  // Billing (api/billing) — subscription + entitlement mutations, mirrored to the\n  // central audit trail (these also write to the service-local billing_events\n  // collection). `details` carry plan/tier/addon ids only — never card/payment\n  // secrets or an AWS account id.\n  // Subscription lifecycle a CUSTOMER drives (the admin counterpart is\n  // `billing.tier.override`): self-serve create (direct or Marketplace claim),\n  // plan/interval change, cancel-at-period-end, undo-cancel, cascade delete.\n  'billing.subscription.create',\n  'billing.subscription.update',\n  'billing.subscription.reactivate',\n  'billing.subscription.cancel',\n  'billing.subscription.delete',\n  'billing.tier.override',\n  // Operator-only reseed of the invoice ledger from the payment provider's\n  // history (POST /billing/admin/backfill) — mutates finance data fleet-wide.\n  'billing.addon.add',\n  'billing.addon.remove',\n  // System-initiated removal of a tier-included add-on on a plan upgrade (the\n  // account's new tier now bundles the feature) — distinct from a user-initiated\n  // `remove` so finance can tell an auto-prune from a customer action.\n  'billing.addon.prune',\n  // Discounts (docs/billing-discounts.md) — mint/issue/apply/remove/revoke of a\n  // price coupon or usage credit. `details` carry the discount id + kind/value\n  // only, never the opaque token or signing key.\n  'billing.discount.generate',\n  'billing.discount.issue',\n  'billing.discount.apply',\n  'billing.discount.remove',\n  'billing.discount.revoke',\n  // Promotions (docs/billing-discounts.md#promotions) — rule-driven auto-grant\n  // campaigns. `details` carry the promotion id + cents/event only.\n  'billing.promotion.create',\n  'billing.promotion.update',\n  'billing.promotion.revoke',\n  'billing.promotion.grant',\n  'billing.promotion.activate',\n  // Usage-credit realization — a customer/compliance-visible record of credit\n  // movement: `consumed` (Marketplace metered drawdown), `exhausted` (balance hit\n  // zero), and a combo ending. `details` carry cents/ids only, no payment secrets.\n  'billing.credit.consumed',\n  'billing.credit.exhausted',\n  'billing.combo.expired',\n  // Reporting (api/reporting) — the three reporting mutations whose effect\n  // outlives a request log: the per-org correlation-window config write, a\n  // post-deploy outcome marker (it moves the org's DORA CFR/MTTR), and the\n  // inbound billing→reporting retention-entitlement sync (a retention cut is a\n  // data-destroying change applied by the next sweep). `details` carry the\n  // settings/outcome values only.\n  'reporting.settings.update',\n  'reporting.deployment.outcome',\n  'reporting.retention.sync',\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  'authz.denied',\n  // \"Ask\" assistant activity — visibility into what the assistant did on a user's\n  // behalf. `ask.query` is a read-only how-to turn; `ask.agent.turn` is a tool-calling\n  // turn. `details` carry SAFE METADATA ONLY (tools used, proposal kinds, query\n  // length, outcome), never the raw query text.\n  'ask.query',\n  'ask.agent.turn',\n  // Plugin ecosystem (docs/runbooks/ecosystem-moderation.md). Governance actions\n  // are recorded with `orgId` = the system org; `affectedOrgId` is the\n  // publisher's org (listing/version/review/advisory/publisher moderation) or\n  // the installing org (installs + policy). Anonymous submissions use the\n  // `ANONYMOUS_ACTOR_ID` actor with `details.submissionId`. `details` carry ids,\n  // versions, digests, tier, state and reason codes only — never review bodies,\n  // README content, secrets or emails.\n  // Publishers.\n  'publisher.create',\n  'publisher.update',\n  'publisher.terms.accept',\n  'publisher.verify.request',\n  'publisher.verify.approve',\n  'publisher.verify.reject',\n  'publisher.tier.change',\n  'publisher.suspend',\n  'publisher.unsuspend',\n  'publisher.transfer.request',\n  'publisher.transfer.accept',\n  'publisher.transfer.decline',\n  'publisher.transfer.approve',\n  'publisher.transfer.reject',\n  'publisher.profile-change.approve',\n  'publisher.profile-change.reject',\n  // Publish requests (tenant → system org). `details.kind` names the request.\n  'plugin.request.submit',\n  'plugin.request.withdraw',\n  'plugin.request.approve',\n  'plugin.request.second-approve',\n  'plugin.request.reject',\n  'plugin.request.auto-approve',\n  // Listings and versions (system org, except the tenant pause).\n  'plugin.listing.publish',\n  'plugin.listing.unlist',\n  'plugin.listing.update',\n  'plugin.listing.state.change',\n  'plugin.listing.pause',\n  'plugin.listing.unpause',\n  'plugin.version.pause',\n  'plugin.version.yank',\n  'plugin.version.unyank',\n  'plugin.version.deprecate',\n  'plugin.collection.update',\n  // Ecosystem configuration (system org).\n  'ecosystem.auto-approval-rule.create',\n  'ecosystem.auto-approval-rule.update',\n  'ecosystem.auto-approval-rule.delete',\n  'ecosystem.reserved-name.update',\n  'ecosystem.sla.update',\n  // Public registry namespace (`public/*`): copy + sign + attest on publish,\n  // the tier-change/suspension re-sign job, tag removal on yank/takedown, and\n  // the retention sweep.\n  'registry.image.publish',\n  'registry.image.resign',\n  'registry.image.yank',\n  'registry.image.gc',\n  // Installs and the installing org's consumption policy (org-local).\n  'plugin.install.request',\n  'plugin.install.approve',\n  'plugin.install.deny',\n  'plugin.install.create',\n  'plugin.install.upgrade',\n  // A member's request to change an install past what they may do alone, and its decision.\n  'plugin.install.change-request',\n  'plugin.install.change-approve',\n  'plugin.install.change-reject',\n  'plugin.install.remove',\n  'org.plugin-install-policy.update',\n  // Reviews and replies.\n  'plugin.review.create',\n  'plugin.review.update',\n  'plugin.review.delete',\n  'plugin.review.report',\n  'plugin.review.hold',\n  'plugin.review.release',\n  'plugin.review.remove',\n  'plugin.review.anonymize',\n  'plugin.review.reply.create',\n  'plugin.review.reply.update',\n  'plugin.review.reply.delete',\n  // Anonymous submissions.\n  'plugin.submission.create',\n  'plugin.submission.verify',\n  'plugin.submission.gate-fail',\n  'plugin.submission.approve',\n  'plugin.submission.reject',\n  'plugin.submission.claim',\n  'plugin.submission.expire',\n  // Security advisories (publish/withdraw are system-org only; update = a\n  // moderator editing a draft before it is published).\n  'plugin.advisory.create',\n  'plugin.advisory.update',\n  'plugin.advisory.publish',\n  'plugin.advisory.withdraw',\n  // Per-org plugin security notifications (plugin scan gates): the settings\n  // (recipients, digest, webhook, external address — changed field names and\n  // the webhook host only, never the secret or the address), an external\n  // address confirmed through its emailed single-use link, and a test send.\n  'plugin.security_notifications.update',\n  'plugin.security_notifications.external_email.verify',\n  'plugin.security_notifications.test',\n] as const;\n\nexport type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];\n\n/** Whether `value` is an action a remote service may emit (the ingest allow-list). */\nexport function isRemoteAuditAction(value: string): value is RemoteAuditAction {\n  return (REMOTE_AUDIT_ACTIONS as readonly string[]).includes(value);\n}\n"]}

package/lib/utils/date.d.ts

@@ -0,0 +1,19 @@
+/** Date coercions for the JSON boundary. */
+/**
+ * A nullable timestamp as an ISO-8601 string, or `null` when there is no date.
+ *
+ * The shape every API response needs at the DB→JSON boundary: Postgres and
+ * Mongo hand back `Date | null`, the wire wants `string | null`, and a bare
+ * `row.x?.toISOString() ?? null` breaks the moment the driver returns a string
+ * instead (Mongo aggregation output, a `::text` cast, a cached row rehydrated
+ * from JSON). Normalizing through `new Date(d)` handles both.
+ *
+ * Falsy in, `null` out — which folds the epoch (`new Date(0)`) to `null` too.
+ * That is intentional and matches every hand-rolled copy this replaces: a
+ * zero timestamp in this codebase means "unset", never 1970.
+ *
+ * Throws `RangeError` on an unparseable string, deliberately: a malformed
+ * timestamp is a data-integrity problem, and silently serving `null` for it
+ * would hide a corrupt row behind a plausible-looking response.
+ */
+export declare const isoOrNull: (d: Date | string | number | null | undefined) => string | null;

package/lib/utils/date.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/** Date coercions for the JSON boundary. */
+/**
+ * A nullable timestamp as an ISO-8601 string, or `null` when there is no date.
+ *
+ * The shape every API response needs at the DB→JSON boundary: Postgres and
+ * Mongo hand back `Date | null`, the wire wants `string | null`, and a bare
+ * `row.x?.toISOString() ?? null` breaks the moment the driver returns a string
+ * instead (Mongo aggregation output, a `::text` cast, a cached row rehydrated
+ * from JSON). Normalizing through `new Date(d)` handles both.
+ *
+ * Falsy in, `null` out — which folds the epoch (`new Date(0)`) to `null` too.
+ * That is intentional and matches every hand-rolled copy this replaces: a
+ * zero timestamp in this codebase means "unset", never 1970.
+ *
+ * Throws `RangeError` on an unparseable string, deliberately: a malformed
+ * timestamp is a data-integrity problem, and silently serving `null` for it
+ * would hide a corrupt row behind a plausible-looking response.
+ */
+export const isoOrNull = (d) => (d ? new Date(d).toISOString() : null);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/dsse.d.ts

@@ -0,0 +1,32 @@
+/**
+ * DSSE-envelope parsing for cosign attestation output.
+ *
+ * `cosign verify-attestation` prints one DSSE envelope per VERIFIED attestation,
+ * one JSON object per line:
+ * `{ payloadType, payload: base64(in-toto statement), signatures }`.
+ * Signature verification has already happened in cosign by the time we see this
+ * — this module only decodes what cosign vouched for.
+ *
+ * This lives in api-core because BOTH the plugin service (build-time SBOM read)
+ * and the image-registry service (registry-side signed-SBOM read) parse the same
+ * output. Two hand-copied parse loops in supply-chain verification code is a
+ * security risk, not untidiness: a fix applied to one copy silently leaves the
+ * other accepting what it should not.
+ *
+ * Callers keep their OWN not-found policy on top (throw vs. return null) —
+ * that is a per-service decision, the parse is not.
+ */
+/** in-toto predicate type for an SPDX SBOM, as cosign's `--type spdxjson` emits. */
+export declare const SPDX_PREDICATE_TYPE = "https://spdx.dev/Document";
+/**
+ * Return the predicate of the LAST envelope in `stdout` whose in-toto statement
+ * carries `predicateType`, or null when none does.
+ *
+ * LAST, not first: a rebuild re-attests the same digest and cosign lists
+ * attestations oldest-first, so the newest attestation is the final line.
+ *
+ * Lines that are not parseable envelopes are skipped rather than fatal — cosign
+ * prints nothing else on stdout today, but stray output must not turn a valid
+ * attestation into a verification failure.
+ */
+export declare function extractPredicate(stdout: string, predicateType: string): Record<string, unknown> | null;

package/lib/utils/dsse.js

@@ -0,0 +1,55 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * DSSE-envelope parsing for cosign attestation output.
+ *
+ * `cosign verify-attestation` prints one DSSE envelope per VERIFIED attestation,
+ * one JSON object per line:
+ * `{ payloadType, payload: base64(in-toto statement), signatures }`.
+ * Signature verification has already happened in cosign by the time we see this
+ * — this module only decodes what cosign vouched for.
+ *
+ * This lives in api-core because BOTH the plugin service (build-time SBOM read)
+ * and the image-registry service (registry-side signed-SBOM read) parse the same
+ * output. Two hand-copied parse loops in supply-chain verification code is a
+ * security risk, not untidiness: a fix applied to one copy silently leaves the
+ * other accepting what it should not.
+ *
+ * Callers keep their OWN not-found policy on top (throw vs. return null) —
+ * that is a per-service decision, the parse is not.
+ */
+/** in-toto predicate type for an SPDX SBOM, as cosign's `--type spdxjson` emits. */
+export const SPDX_PREDICATE_TYPE = 'https://spdx.dev/Document';
+/**
+ * Return the predicate of the LAST envelope in `stdout` whose in-toto statement
+ * carries `predicateType`, or null when none does.
+ *
+ * LAST, not first: a rebuild re-attests the same digest and cosign lists
+ * attestations oldest-first, so the newest attestation is the final line.
+ *
+ * Lines that are not parseable envelopes are skipped rather than fatal — cosign
+ * prints nothing else on stdout today, but stray output must not turn a valid
+ * attestation into a verification failure.
+ */
+export function extractPredicate(stdout, predicateType) {
+    let predicate = null;
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        try {
+            const envelope = JSON.parse(trimmed);
+            if (!envelope.payload)
+                continue;
+            const statement = JSON.parse(Buffer.from(envelope.payload, 'base64').toString('utf-8'));
+            if (statement.predicateType === predicateType && statement.predicate && typeof statement.predicate === 'object') {
+                predicate = statement.predicate;
+            }
+        }
+        catch {
+            // Not an envelope line.
+        }
+    }
+    return predicate;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/index.d.ts

@@ -3,13 +3,14 @@ export * from './api-key.js';
 export * from './safe-require.js';
 export * from './secure-compare.js';
 export * from './crash-handlers.js';
-export { sendSuccess, sendError, sendQuotaExceeded, sendPaginatedNested, extractDbError, errorMessage, sendBadRequest, sendInternalError, parsePaginationParams, parseSort, type PaginationParams, type SortParams, } from './response.js';
+export { sendSuccess, sendError, sendQuotaExceeded, sendPaginatedNested, paginationMeta, type PaginationMeta, extractDbError, errorMessage, sendBadRequest, sendInternalError, parsePaginationParams, type PaginationParams, type SortParams, } from './response.js';
 export { getParam, parseQueryInt, parseQueryString, parseOptionalDate, parsePositiveInt, parseQueryIntClamped, parsePage, validateBulkArray, parseReportInterval, parseDateRange, type Page, REPORT_INTERVALS, } from './params.js';
 export * from './headers.js';
 export * from './identity.js';
 export { USER_TOKEN_ALGORITHM, USER_TOKEN_CURVE, JWKS_PATH, decodeJwtHeader, isJwksDocument, publicJwkFrom, derToJoseSignature, encodeJwsSigningInput, compactJws, } from './jwk.js';
 export type { PublicJwk, JwksDocument, } from './jwk.js';
 export * from './object.js';
+export * from './date.js';
 export { resetSupportAliasesCache, getPrimarySupportAlias, getAllSupportAliases, resolveRecipientAlias, DEFAULT_SUPPORT_ALIAS, } from './alias-resolver.js';
 export * from './concurrency.js';
 export * from './audit.js';
@@ -17,6 +18,7 @@ export { getDefaultKeyProvider, resetDefaultKeyProvider, setKeyProvider, encrypt
 export * from './secret-rotation.js';
 export { setCounterEmitter, resetCounterEmitter, emitCounter, } from './metric-emitter.js';
 export * from './aws-scrub.js';
+export { extractPredicate, SPDX_PREDICATE_TYPE, } from './dsse.js';
 export { maskLine, looksSensitive, REDACTED, SENSITIVE_VALUE_PATTERNS, } from './sensitive-patterns.js';
 export { isPrivateAddress, assertSafeUrl, safeFetch, type SafeFetchResponse, } from './ssrf.js';
 export * from './env.js';

package/lib/utils/index.js

@@ -5,7 +5,7 @@ export * from './api-key.js';
 export * from './safe-require.js';
 export * from './secure-compare.js';
 export * from './crash-handlers.js';
-export { sendSuccess, sendError, sendQuotaExceeded, sendPaginatedNested, extractDbError, errorMessage, sendBadRequest, sendInternalError, parsePaginationParams, parseSort, } from './response.js';
+export { sendSuccess, sendError, sendQuotaExceeded, sendPaginatedNested, paginationMeta, extractDbError, errorMessage, sendBadRequest, sendInternalError, parsePaginationParams, } from './response.js';
 export { getParam, parseQueryInt, parseQueryString, parseOptionalDate, parsePositiveInt, parseQueryIntClamped, parsePage, validateBulkArray, parseReportInterval, parseDateRange, REPORT_INTERVALS, } from './params.js';
 export * from './headers.js';
 export * from './identity.js';
@@ -16,6 +16,7 @@ export * from './identity.js';
 // leaking them to every service.
 export { USER_TOKEN_ALGORITHM, USER_TOKEN_CURVE, JWKS_PATH, decodeJwtHeader, isJwksDocument, publicJwkFrom, derToJoseSignature, encodeJwsSigningInput, compactJws, } from './jwk.js';
 export * from './object.js';
+export * from './date.js';
 export { resetSupportAliasesCache, getPrimarySupportAlias, getAllSupportAliases, resolveRecipientAlias, DEFAULT_SUPPORT_ALIAS, } from './alias-resolver.js';
 export * from './concurrency.js';
 export * from './audit.js';
@@ -23,6 +24,7 @@ export { getDefaultKeyProvider, resetDefaultKeyProvider, setKeyProvider, encrypt
 export * from './secret-rotation.js';
 export { setCounterEmitter, resetCounterEmitter, emitCounter, } from './metric-emitter.js';
 export * from './aws-scrub.js';
+export { extractPredicate, SPDX_PREDICATE_TYPE, } from './dsse.js';
 export { maskLine, looksSensitive, REDACTED, SENSITIVE_VALUE_PATTERNS, } from './sensitive-patterns.js';
 export { isPrivateAddress, assertSafeUrl, safeFetch, } from './ssrf.js';
 export * from './env.js';
@@ -30,4 +32,4 @@ export * from './service-registry.js';
 export * from './retention.js';
 export * from './compliance-attributes.js';
 export { leadingZeroBits, proofOfWorkHash, challengeKey, clampDifficulty, createProofOfWorkChallenge, parseProofOfWorkChallenge, verifyProofOfWork, solveProofOfWork, POW_DEFAULT_DIFFICULTY, POW_MAX_DIFFICULTY, POW_CHALLENGE_TTL_MS, } from './proof-of-work.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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