@pipeline-builder/api-core 4.1.13 → 4.1.15

package/lib/utils/plugin-compliance.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Plugin compliance attributes: what the plugin service tells compliance about
+ * an uploaded plugin and its pushed image, derived from the stored plugin row.
+ */
+/**
+ * The attributes the plugin service sends to `/compliance/validate/plugin`.
+ *
+ * The spec/config fields describe the plugin as uploaded. The image fields
+ * describe what the platform itself established about the pushed image — the
+ * facts the curated SOC2/PCI/CIS plugin rules evaluate:
+ *
+ * - `signed`: the image digest carries the platform's cosign signature.
+ * - `scanned`: a vulnerability scan completed (`scannedAt` is set); the
+ *   `vuln*` counts are present only then — an unscanned image sends no counts,
+ *   so a numeric rule like `vulnCritical lt 1` cannot pass on a missing value.
+ * - `runAsRoot`: the image config's effective USER is root (empty, `0`, `root`).
+ * - `packages`: package names from the signed SBOM.
+ * - `tags`: the plugin's keywords plus `key=value` labels (CIS 2.1 inventory).
+ *
+ * Image fields are unknown until the build worker has pushed, signed and
+ * scanned the image; the upload-time check lists them in `deferredFields`
+ * and the worker re-validates once they are real.
+ */
+export interface PluginComplianceAttributes {
+    name?: string;
+    version?: string;
+    pluginType?: string;
+    computeType?: string;
+    timeout?: number | null;
+    failureBehavior?: string;
+    env?: Record<string, string>;
+    buildArgs?: Record<string, string>;
+    installCommands?: string[];
+    commands?: string[];
+    visibility?: string;
+    secrets?: unknown[];
+    metadata?: Record<string, unknown>;
+    keywords?: string[];
+    buildType?: string;
+    tags?: string[];
+    signed?: boolean;
+    scanned?: boolean;
+    vulnCritical?: number;
+    vulnHigh?: number;
+    vulnMedium?: number;
+    vulnLow?: number;
+    runAsRoot?: boolean;
+    packages?: string[];
+    [key: string]: unknown;
+}
+/** Plugin attributes only the build worker can establish (see {@link PluginComplianceAttributes}). */
+export declare const PLUGIN_IMAGE_COMPLIANCE_FIELDS: readonly ['signed', 'scanned', 'vulnCritical', 'vulnHigh', 'vulnMedium', 'vulnLow', 'runAsRoot', 'packages'];
+export type PluginImageComplianceField = typeof PLUGIN_IMAGE_COMPLIANCE_FIELDS[number];
+/** The stored plugin-row columns the image facts derive from (any subset). */
+export interface PluginImageRow {
+    buildType?: unknown;
+    pluginType?: unknown;
+    imageDigest?: unknown;
+    scannedAt?: unknown;
+    vulnCritical?: unknown;
+    vulnHigh?: unknown;
+    vulnMedium?: unknown;
+    vulnLow?: unknown;
+    runAsRoot?: unknown;
+    keywords?: unknown;
+    labels?: unknown;
+}
+/**
+ * Whether a plugin runs on its own image: `metadata_only` builds none and a
+ * `ManualApprovalStep` never runs one. Same rule as the plugin worker's skip.
+ */
+export declare function pluginRunsOwnImage(row: Pick<PluginImageRow, 'buildType' | 'pluginType'>): boolean;
+/** CIS 2.1 inventory tags: the plugin's keywords plus its labels as `key=value`. */
+export declare function pluginComplianceTags(keywords: unknown, labels?: unknown): string[];
+/**
+ * The image-derived compliance attributes of a STORED plugin row (the plugin
+ * service's update re-check, the build worker's post-build check, and the
+ * compliance service's scans and entity events all derive them here, so the
+ * rules see one definition of `signed`/`scanned`).
+ *
+ * - `signed`: the row carries a well-formed digest. The worker stores a digest
+ *   only after image-registry signed it (a signing failure fails the build), so
+ *   a digest on the row IS a platform signature.
+ * - `scanned` + `vuln*`: counts only when `scannedAt` is set.
+ * - `runAsRoot`: only when known.
+ * - `packages`: not a row column. Pass the SBOM's names when you have them,
+ *   `null` when the SBOM could not be read (attribute omitted, so a
+ *   `$count(packages)` rule sees 0), or leave it `undefined` on a path that
+ *   never reads SBOMs — it is then returned in `deferredFields` (it was
+ *   evaluated by the post-build check and cannot change without a rebuild).
+ *
+ * A plugin that runs no image of its own is honestly unsigned and unscanned
+ * with no packages; nothing is deferred for it.
+ */
+export declare function derivePluginImageCompliance(row: PluginImageRow, packages?: string[] | null): {
+    attributes: PluginComplianceAttributes;
+    deferredFields: PluginImageComplianceField[];
+};

package/lib/utils/plugin-compliance.js

@@ -0,0 +1,78 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/** Plugin attributes only the build worker can establish (see {@link PluginComplianceAttributes}). */
+export const PLUGIN_IMAGE_COMPLIANCE_FIELDS = [
+    'signed', 'scanned', 'vulnCritical', 'vulnHigh', 'vulnMedium', 'vulnLow', 'runAsRoot', 'packages',
+];
+const SIGNED_DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+/**
+ * Whether a plugin runs on its own image: `metadata_only` builds none and a
+ * `ManualApprovalStep` never runs one. Same rule as the plugin worker's skip.
+ */
+export function pluginRunsOwnImage(row) {
+    return row.buildType !== 'metadata_only' && row.pluginType !== 'ManualApprovalStep';
+}
+/** CIS 2.1 inventory tags: the plugin's keywords plus its labels as `key=value`. */
+export function pluginComplianceTags(keywords, labels) {
+    const tags = new Set();
+    if (Array.isArray(keywords)) {
+        for (const k of keywords)
+            if (typeof k === 'string' && k.trim())
+                tags.add(k.trim());
+    }
+    if (labels && typeof labels === 'object' && !Array.isArray(labels)) {
+        for (const [k, v] of Object.entries(labels)) {
+            if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')
+                tags.add(`${k}=${String(v)}`);
+        }
+    }
+    return [...tags];
+}
+const finiteCount = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+/**
+ * The image-derived compliance attributes of a STORED plugin row (the plugin
+ * service's update re-check, the build worker's post-build check, and the
+ * compliance service's scans and entity events all derive them here, so the
+ * rules see one definition of `signed`/`scanned`).
+ *
+ * - `signed`: the row carries a well-formed digest. The worker stores a digest
+ *   only after image-registry signed it (a signing failure fails the build), so
+ *   a digest on the row IS a platform signature.
+ * - `scanned` + `vuln*`: counts only when `scannedAt` is set.
+ * - `runAsRoot`: only when known.
+ * - `packages`: not a row column. Pass the SBOM's names when you have them,
+ *   `null` when the SBOM could not be read (attribute omitted, so a
+ *   `$count(packages)` rule sees 0), or leave it `undefined` on a path that
+ *   never reads SBOMs — it is then returned in `deferredFields` (it was
+ *   evaluated by the post-build check and cannot change without a rebuild).
+ *
+ * A plugin that runs no image of its own is honestly unsigned and unscanned
+ * with no packages; nothing is deferred for it.
+ */
+export function derivePluginImageCompliance(row, packages) {
+    const tags = pluginComplianceTags(row.keywords, row.labels);
+    if (!pluginRunsOwnImage(row)) {
+        return { attributes: { tags, signed: false, scanned: false, packages: [] }, deferredFields: [] };
+    }
+    const scanned = row.scannedAt !== null && row.scannedAt !== undefined;
+    const attributes = {
+        tags,
+        signed: typeof row.imageDigest === 'string' && SIGNED_DIGEST_RE.test(row.imageDigest),
+        scanned,
+    };
+    if (scanned) {
+        attributes.vulnCritical = finiteCount(row.vulnCritical);
+        attributes.vulnHigh = finiteCount(row.vulnHigh);
+        attributes.vulnMedium = finiteCount(row.vulnMedium);
+        attributes.vulnLow = finiteCount(row.vulnLow);
+    }
+    if (typeof row.runAsRoot === 'boolean')
+        attributes.runAsRoot = row.runAsRoot;
+    if (Array.isArray(packages))
+        attributes.packages = packages;
+    for (const k of Object.keys(attributes))
+        if (attributes[k] === undefined)
+            delete attributes[k];
+    return { attributes, deferredFields: packages === undefined ? ['packages'] : [] };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-compliance.js","sourceRoot":"","sources":["../../src/utils/plugin-compliance.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Plugin compliance attributes: what the plugin service tells compliance about\n * an uploaded plugin and its pushed image, derived from the stored plugin row.\n */\n\n/**\n * The attributes the plugin service sends to `/compliance/validate/plugin`.\n *\n * The spec/config fields describe the plugin as uploaded. The image fields\n * describe what the platform itself established about the pushed image — the\n * facts the curated SOC2/PCI/CIS plugin rules evaluate:\n *\n * - `signed`: the image digest carries the platform's cosign signature.\n * - `scanned`: a vulnerability scan completed (`scannedAt` is set); the\n *   `vuln*` counts are present only then — an unscanned image sends no counts,\n *   so a numeric rule like `vulnCritical lt 1` cannot pass on a missing value.\n * - `runAsRoot`: the image config's effective USER is root (empty, `0`, `root`).\n * - `packages`: package names from the signed SBOM.\n * - `tags`: the plugin's keywords plus `key=value` labels (CIS 2.1 inventory).\n *\n * Image fields are unknown until the build worker has pushed, signed and\n * scanned the image; the upload-time check lists them in `deferredFields`\n * and the worker re-validates once they are real.\n */\nexport interface PluginComplianceAttributes {\n  name?: string;\n  version?: string;\n  pluginType?: string;\n  computeType?: string;\n  timeout?: number | null;\n  failureBehavior?: string;\n  env?: Record<string, string>;\n  buildArgs?: Record<string, string>;\n  installCommands?: string[];\n  commands?: string[];\n  visibility?: string;\n  secrets?: unknown[];\n  metadata?: Record<string, unknown>;\n  keywords?: string[];\n  buildType?: string;\n  tags?: string[];\n  signed?: boolean;\n  scanned?: boolean;\n  vulnCritical?: number;\n  vulnHigh?: number;\n  vulnMedium?: number;\n  vulnLow?: number;\n  runAsRoot?: boolean;\n  packages?: string[];\n  [key: string]: unknown;\n}\n\n/** Plugin attributes only the build worker can establish (see {@link PluginComplianceAttributes}). */\nexport const PLUGIN_IMAGE_COMPLIANCE_FIELDS = [\n  'signed', 'scanned', 'vulnCritical', 'vulnHigh', 'vulnMedium', 'vulnLow', 'runAsRoot', 'packages',\n] as const;\nexport type PluginImageComplianceField = typeof PLUGIN_IMAGE_COMPLIANCE_FIELDS[number];\n\n/** The stored plugin-row columns the image facts derive from (any subset). */\nexport interface PluginImageRow {\n  buildType?: unknown;\n  pluginType?: unknown;\n  imageDigest?: unknown;\n  scannedAt?: unknown;\n  vulnCritical?: unknown;\n  vulnHigh?: unknown;\n  vulnMedium?: unknown;\n  vulnLow?: unknown;\n  runAsRoot?: unknown;\n  keywords?: unknown;\n  labels?: unknown;\n}\n\nconst SIGNED_DIGEST_RE = /^sha256:[0-9a-f]{64}$/;\n\n/**\n * Whether a plugin runs on its own image: `metadata_only` builds none and a\n * `ManualApprovalStep` never runs one. Same rule as the plugin worker's skip.\n */\nexport function pluginRunsOwnImage(row: Pick<PluginImageRow, 'buildType' | 'pluginType'>): boolean {\n  return row.buildType !== 'metadata_only' && row.pluginType !== 'ManualApprovalStep';\n}\n\n/** CIS 2.1 inventory tags: the plugin's keywords plus its labels as `key=value`. */\nexport function pluginComplianceTags(keywords: unknown, labels?: unknown): string[] {\n  const tags = new Set<string>();\n  if (Array.isArray(keywords)) {\n    for (const k of keywords) if (typeof k === 'string' && k.trim()) tags.add(k.trim());\n  }\n  if (labels && typeof labels === 'object' && !Array.isArray(labels)) {\n    for (const [k, v] of Object.entries(labels as Record<string, unknown>)) {\n      if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') tags.add(`${k}=${String(v)}`);\n    }\n  }\n  return [...tags];\n}\n\nconst finiteCount = (v: unknown): number | undefined =>\n  typeof v === 'number' && Number.isFinite(v) ? v : undefined;\n\n/**\n * The image-derived compliance attributes of a STORED plugin row (the plugin\n * service's update re-check, the build worker's post-build check, and the\n * compliance service's scans and entity events all derive them here, so the\n * rules see one definition of `signed`/`scanned`).\n *\n * - `signed`: the row carries a well-formed digest. The worker stores a digest\n *   only after image-registry signed it (a signing failure fails the build), so\n *   a digest on the row IS a platform signature.\n * - `scanned` + `vuln*`: counts only when `scannedAt` is set.\n * - `runAsRoot`: only when known.\n * - `packages`: not a row column. Pass the SBOM's names when you have them,\n *   `null` when the SBOM could not be read (attribute omitted, so a\n *   `$count(packages)` rule sees 0), or leave it `undefined` on a path that\n *   never reads SBOMs — it is then returned in `deferredFields` (it was\n *   evaluated by the post-build check and cannot change without a rebuild).\n *\n * A plugin that runs no image of its own is honestly unsigned and unscanned\n * with no packages; nothing is deferred for it.\n */\nexport function derivePluginImageCompliance(\n  row: PluginImageRow,\n  packages?: string[] | null,\n): { attributes: PluginComplianceAttributes; deferredFields: PluginImageComplianceField[] } {\n  const tags = pluginComplianceTags(row.keywords, row.labels);\n  if (!pluginRunsOwnImage(row)) {\n    return { attributes: { tags, signed: false, scanned: false, packages: [] }, deferredFields: [] };\n  }\n  const scanned = row.scannedAt !== null && row.scannedAt !== undefined;\n  const attributes: PluginComplianceAttributes = {\n    tags,\n    signed: typeof row.imageDigest === 'string' && SIGNED_DIGEST_RE.test(row.imageDigest),\n    scanned,\n  };\n  if (scanned) {\n    attributes.vulnCritical = finiteCount(row.vulnCritical);\n    attributes.vulnHigh = finiteCount(row.vulnHigh);\n    attributes.vulnMedium = finiteCount(row.vulnMedium);\n    attributes.vulnLow = finiteCount(row.vulnLow);\n  }\n  if (typeof row.runAsRoot === 'boolean') attributes.runAsRoot = row.runAsRoot;\n  if (Array.isArray(packages)) attributes.packages = packages;\n  for (const k of Object.keys(attributes)) if (attributes[k] === undefined) delete attributes[k];\n  return { attributes, deferredFields: packages === undefined ? ['packages'] : [] };\n}\n"]}

package/lib/utils/proof-of-work.d.ts

@@ -0,0 +1,69 @@
+/** Default leading-zero-bit difficulty (≈1M hashes; a second or two in a browser). */
+export declare const POW_DEFAULT_DIFFICULTY = 20;
+/** Hard ceiling on a difficulty an operator can configure. */
+export declare const POW_MAX_DIFFICULTY = 32;
+/** How long a challenge stays solvable. */
+export declare const POW_CHALLENGE_TTL_MS: number;
+/** What the challenge route returns. */
+export interface ProofOfWorkChallenge {
+    challenge: string;
+    difficulty: number;
+    expiresAt: string;
+}
+/** The signed body of a challenge. */
+export interface ProofOfWorkChallengeBody {
+    nonce: string;
+    difficulty: number;
+    /** Expiry, epoch ms. */
+    exp: number;
+}
+/** A client's answer. */
+export interface ProofOfWorkSolution {
+    challenge: string;
+    nonce: string;
+}
+export type ProofOfWorkRefusal = 'malformed' | 'bad_signature' | 'expired' | 'too_easy' | 'insufficient_work';
+export type ProofOfWorkVerdict = {
+    ok: true;
+    key: string;
+    expiresAt: number;
+    difficulty: number;
+} | {
+    ok: false;
+    reason: ProofOfWorkRefusal;
+};
+/** Number of leading zero BITS in `bytes`. */
+export declare function leadingZeroBits(bytes: Uint8Array): number;
+/** The hash a solution is judged on: `sha256("<challenge>:<nonce>")`. */
+export declare function proofOfWorkHash(challenge: string, nonce: string): Buffer;
+/** The single-use key for a challenge (hex sha256 of the challenge string). */
+export declare function challengeKey(challenge: string): string;
+/** Clamp a configured difficulty into [1, {@link POW_MAX_DIFFICULTY}]. */
+export declare function clampDifficulty(difficulty: number): number;
+/** Issue a fresh signed challenge. */
+export declare function createProofOfWorkChallenge(secret: string, opts?: {
+    difficulty?: number;
+    ttlMs?: number;
+    now?: number;
+}): ProofOfWorkChallenge;
+/**
+ * Decode a challenge and check its signature. Null when it is malformed or
+ * was not signed with `secret` (expiry is NOT checked here).
+ */
+export declare function parseProofOfWorkChallenge(challenge: string, secret: string): ProofOfWorkChallengeBody | null;
+/**
+ * Verify a solution: a genuine, unexpired challenge (signed with `secret`),
+ * at least `minDifficulty` hard, whose hash with `nonce` has enough leading
+ * zero bits. Does NOT enforce single use — store {@link ProofOfWorkVerdict.key}.
+ */
+export declare function verifyProofOfWork(solution: Partial<ProofOfWorkSolution> | null | undefined, secret: string, opts?: {
+    now?: number;
+    minDifficulty?: number;
+}): ProofOfWorkVerdict;
+/**
+ * Find a nonce for `challenge` (tests, the CLI). Counts up from 0; throws
+ * after `maxIterations` so a mistaken difficulty can't spin forever.
+ */
+export declare function solveProofOfWork(challenge: string, difficulty: number, opts?: {
+    maxIterations?: number;
+}): string;

package/lib/utils/proof-of-work.js

@@ -0,0 +1,139 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Self-hosted hashcash proof-of-work for the anonymous plugin submission API
+ * (docs/plugin-publishing.md): no third-party captcha, so it
+ * works air-gapped.
+ *
+ * A CHALLENGE is `base64url(JSON{ nonce, difficulty, exp }) + '.' +
+ * base64url(HMAC-SHA256(body, secret))` — stateless, so any replica can verify
+ * one another replica issued. A SOLUTION is a decimal-string `nonce` such that
+ * `sha256("<challenge>:<nonce>")` starts with at least `difficulty` zero BITS.
+ * Single use is the caller's job (a Redis `SET NX` on {@link challengeKey}
+ * with the remaining lifetime as TTL): nothing here remembers anything.
+ *
+ * Pure and dependency-free apart from node:crypto, so the frontend can mirror
+ * the algorithm exactly (its solver runs in a Web Worker with crypto.subtle)
+ * and the CLI and tests can solve with {@link solveProofOfWork}.
+ */
+import { createHash, createHmac, randomBytes, timingSafeEqual } from 'crypto';
+/** Default leading-zero-bit difficulty (≈1M hashes; a second or two in a browser). */
+export const POW_DEFAULT_DIFFICULTY = 20;
+/** Hard ceiling on a difficulty an operator can configure. */
+export const POW_MAX_DIFFICULTY = 32;
+/** How long a challenge stays solvable. */
+export const POW_CHALLENGE_TTL_MS = 10 * 60_000;
+/** A nonce is a decimal string of at most this many digits. */
+const NONCE_MAX_DIGITS = 20;
+/** A challenge string is never longer than this (bounds hashing work on garbage input). */
+const CHALLENGE_MAX_LENGTH = 512;
+const b64url = (buf) => buf.toString('base64url');
+function sign(body, secret) {
+    return b64url(createHmac('sha256', secret).update(body).digest());
+}
+/** Number of leading zero BITS in `bytes`. */
+export function leadingZeroBits(bytes) {
+    let bits = 0;
+    for (const byte of bytes) {
+        if (byte === 0) {
+            bits += 8;
+            continue;
+        }
+        // Math.clz32 counts over 32 bits; a byte occupies the low 8.
+        return bits + Math.clz32(byte) - 24;
+    }
+    return bits;
+}
+/** The hash a solution is judged on: `sha256("<challenge>:<nonce>")`. */
+export function proofOfWorkHash(challenge, nonce) {
+    return createHash('sha256').update(`${challenge}:${nonce}`).digest();
+}
+/** The single-use key for a challenge (hex sha256 of the challenge string). */
+export function challengeKey(challenge) {
+    return createHash('sha256').update(challenge).digest('hex');
+}
+/** Clamp a configured difficulty into [1, {@link POW_MAX_DIFFICULTY}]. */
+export function clampDifficulty(difficulty) {
+    if (!Number.isFinite(difficulty))
+        return POW_DEFAULT_DIFFICULTY;
+    return Math.min(POW_MAX_DIFFICULTY, Math.max(1, Math.floor(difficulty)));
+}
+/** Issue a fresh signed challenge. */
+export function createProofOfWorkChallenge(secret, opts = {}) {
+    if (!secret)
+        throw new Error('A proof-of-work secret is required');
+    const now = opts.now ?? Date.now();
+    const body = {
+        nonce: b64url(randomBytes(16)),
+        difficulty: clampDifficulty(opts.difficulty ?? POW_DEFAULT_DIFFICULTY),
+        exp: now + (opts.ttlMs ?? POW_CHALLENGE_TTL_MS),
+    };
+    const encoded = b64url(Buffer.from(JSON.stringify(body), 'utf8'));
+    return { challenge: `${encoded}.${sign(encoded, secret)}`, difficulty: body.difficulty, expiresAt: new Date(body.exp).toISOString() };
+}
+/**
+ * Decode a challenge and check its signature. Null when it is malformed or
+ * was not signed with `secret` (expiry is NOT checked here).
+ */
+export function parseProofOfWorkChallenge(challenge, secret) {
+    if (typeof challenge !== 'string' || challenge.length === 0 || challenge.length > CHALLENGE_MAX_LENGTH)
+        return null;
+    const dot = challenge.indexOf('.');
+    if (dot <= 0 || dot !== challenge.lastIndexOf('.'))
+        return null;
+    const encoded = challenge.slice(0, dot);
+    const given = Buffer.from(challenge.slice(dot + 1), 'base64url');
+    const expected = Buffer.from(sign(encoded, secret), 'base64url');
+    if (given.length !== expected.length || !timingSafeEqual(given, expected))
+        return null;
+    try {
+        const body = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+        if (typeof body.nonce !== 'string' || typeof body.difficulty !== 'number' || typeof body.exp !== 'number')
+            return null;
+        if (!Number.isInteger(body.difficulty) || body.difficulty < 1 || body.difficulty > POW_MAX_DIFFICULTY)
+            return null;
+        return { nonce: body.nonce, difficulty: body.difficulty, exp: body.exp };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Verify a solution: a genuine, unexpired challenge (signed with `secret`),
+ * at least `minDifficulty` hard, whose hash with `nonce` has enough leading
+ * zero bits. Does NOT enforce single use — store {@link ProofOfWorkVerdict.key}.
+ */
+export function verifyProofOfWork(solution, secret, opts = {}) {
+    const challenge = solution?.challenge;
+    const nonce = solution?.nonce;
+    if (typeof challenge !== 'string' || typeof nonce !== 'string')
+        return { ok: false, reason: 'malformed' };
+    if (!/^\d+$/.test(nonce) || nonce.length > NONCE_MAX_DIGITS)
+        return { ok: false, reason: 'malformed' };
+    if (!secret)
+        return { ok: false, reason: 'bad_signature' };
+    const body = parseProofOfWorkChallenge(challenge, secret);
+    if (!body)
+        return { ok: false, reason: 'bad_signature' };
+    if ((opts.now ?? Date.now()) > body.exp)
+        return { ok: false, reason: 'expired' };
+    if (opts.minDifficulty !== undefined && body.difficulty < clampDifficulty(opts.minDifficulty))
+        return { ok: false, reason: 'too_easy' };
+    if (leadingZeroBits(proofOfWorkHash(challenge, nonce)) < body.difficulty)
+        return { ok: false, reason: 'insufficient_work' };
+    return { ok: true, key: challengeKey(challenge), expiresAt: body.exp, difficulty: body.difficulty };
+}
+/**
+ * Find a nonce for `challenge` (tests, the CLI). Counts up from 0; throws
+ * after `maxIterations` so a mistaken difficulty can't spin forever.
+ */
+export function solveProofOfWork(challenge, difficulty, opts = {}) {
+    const max = opts.maxIterations ?? 2 ** 32;
+    for (let i = 0; i < max; i++) {
+        const nonce = String(i);
+        if (leadingZeroBits(proofOfWorkHash(challenge, nonce)) >= difficulty)
+            return nonce;
+    }
+    throw new Error(`No proof-of-work solution within ${max} iterations`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proof-of-work.js","sourceRoot":"","sources":["../../src/utils/proof-of-work.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Self-hosted hashcash proof-of-work for the anonymous plugin submission API\n * (docs/plugin-publishing.md): no third-party captcha, so it\n * works air-gapped.\n *\n * A CHALLENGE is `base64url(JSON{ nonce, difficulty, exp }) + '.' +\n * base64url(HMAC-SHA256(body, secret))` — stateless, so any replica can verify\n * one another replica issued. A SOLUTION is a decimal-string `nonce` such that\n * `sha256(\"<challenge>:<nonce>\")` starts with at least `difficulty` zero BITS.\n * Single use is the caller's job (a Redis `SET NX` on {@link challengeKey}\n * with the remaining lifetime as TTL): nothing here remembers anything.\n *\n * Pure and dependency-free apart from node:crypto, so the frontend can mirror\n * the algorithm exactly (its solver runs in a Web Worker with crypto.subtle)\n * and the CLI and tests can solve with {@link solveProofOfWork}.\n */\n\nimport { createHash, createHmac, randomBytes, timingSafeEqual } from 'crypto';\n\n/** Default leading-zero-bit difficulty (≈1M hashes; a second or two in a browser). */\nexport const POW_DEFAULT_DIFFICULTY = 20;\n/** Hard ceiling on a difficulty an operator can configure. */\nexport const POW_MAX_DIFFICULTY = 32;\n/** How long a challenge stays solvable. */\nexport const POW_CHALLENGE_TTL_MS = 10 * 60_000;\n/** A nonce is a decimal string of at most this many digits. */\nconst NONCE_MAX_DIGITS = 20;\n/** A challenge string is never longer than this (bounds hashing work on garbage input). */\nconst CHALLENGE_MAX_LENGTH = 512;\n\n/** What the challenge route returns. */\nexport interface ProofOfWorkChallenge {\n  challenge: string;\n  difficulty: number;\n  expiresAt: string;\n}\n\n/** The signed body of a challenge. */\nexport interface ProofOfWorkChallengeBody {\n  nonce: string;\n  difficulty: number;\n  /** Expiry, epoch ms. */\n  exp: number;\n}\n\n/** A client's answer. */\nexport interface ProofOfWorkSolution {\n  challenge: string;\n  nonce: string;\n}\n\nexport type ProofOfWorkRefusal = 'malformed' | 'bad_signature' | 'expired' | 'too_easy' | 'insufficient_work';\n\nexport type ProofOfWorkVerdict =\n  | { ok: true; key: string; expiresAt: number; difficulty: number }\n  | { ok: false; reason: ProofOfWorkRefusal };\n\nconst b64url = (buf: Buffer): string => buf.toString('base64url');\n\nfunction sign(body: string, secret: string): string {\n  return b64url(createHmac('sha256', secret).update(body).digest());\n}\n\n/** Number of leading zero BITS in `bytes`. */\nexport function leadingZeroBits(bytes: Uint8Array): number {\n  let bits = 0;\n  for (const byte of bytes) {\n    if (byte === 0) {\n      bits += 8;\n      continue;\n    }\n    // Math.clz32 counts over 32 bits; a byte occupies the low 8.\n    return bits + Math.clz32(byte) - 24;\n  }\n  return bits;\n}\n\n/** The hash a solution is judged on: `sha256(\"<challenge>:<nonce>\")`. */\nexport function proofOfWorkHash(challenge: string, nonce: string): Buffer {\n  return createHash('sha256').update(`${challenge}:${nonce}`).digest();\n}\n\n/** The single-use key for a challenge (hex sha256 of the challenge string). */\nexport function challengeKey(challenge: string): string {\n  return createHash('sha256').update(challenge).digest('hex');\n}\n\n/** Clamp a configured difficulty into [1, {@link POW_MAX_DIFFICULTY}]. */\nexport function clampDifficulty(difficulty: number): number {\n  if (!Number.isFinite(difficulty)) return POW_DEFAULT_DIFFICULTY;\n  return Math.min(POW_MAX_DIFFICULTY, Math.max(1, Math.floor(difficulty)));\n}\n\n/** Issue a fresh signed challenge. */\nexport function createProofOfWorkChallenge(\n  secret: string,\n  opts: { difficulty?: number; ttlMs?: number; now?: number } = {},\n): ProofOfWorkChallenge {\n  if (!secret) throw new Error('A proof-of-work secret is required');\n  const now = opts.now ?? Date.now();\n  const body: ProofOfWorkChallengeBody = {\n    nonce: b64url(randomBytes(16)),\n    difficulty: clampDifficulty(opts.difficulty ?? POW_DEFAULT_DIFFICULTY),\n    exp: now + (opts.ttlMs ?? POW_CHALLENGE_TTL_MS),\n  };\n  const encoded = b64url(Buffer.from(JSON.stringify(body), 'utf8'));\n  return { challenge: `${encoded}.${sign(encoded, secret)}`, difficulty: body.difficulty, expiresAt: new Date(body.exp).toISOString() };\n}\n\n/**\n * Decode a challenge and check its signature. Null when it is malformed or\n * was not signed with `secret` (expiry is NOT checked here).\n */\nexport function parseProofOfWorkChallenge(challenge: string, secret: string): ProofOfWorkChallengeBody | null {\n  if (typeof challenge !== 'string' || challenge.length === 0 || challenge.length > CHALLENGE_MAX_LENGTH) return null;\n  const dot = challenge.indexOf('.');\n  if (dot <= 0 || dot !== challenge.lastIndexOf('.')) return null;\n  const encoded = challenge.slice(0, dot);\n  const given = Buffer.from(challenge.slice(dot + 1), 'base64url');\n  const expected = Buffer.from(sign(encoded, secret), 'base64url');\n  if (given.length !== expected.length || !timingSafeEqual(given, expected)) return null;\n  try {\n    const body = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8')) as Record<string, unknown>;\n    if (typeof body.nonce !== 'string' || typeof body.difficulty !== 'number' || typeof body.exp !== 'number') return null;\n    if (!Number.isInteger(body.difficulty) || body.difficulty < 1 || body.difficulty > POW_MAX_DIFFICULTY) return null;\n    return { nonce: body.nonce, difficulty: body.difficulty, exp: body.exp };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Verify a solution: a genuine, unexpired challenge (signed with `secret`),\n * at least `minDifficulty` hard, whose hash with `nonce` has enough leading\n * zero bits. Does NOT enforce single use — store {@link ProofOfWorkVerdict.key}.\n */\nexport function verifyProofOfWork(\n  solution: Partial<ProofOfWorkSolution> | null | undefined,\n  secret: string,\n  opts: { now?: number; minDifficulty?: number } = {},\n): ProofOfWorkVerdict {\n  const challenge = solution?.challenge;\n  const nonce = solution?.nonce;\n  if (typeof challenge !== 'string' || typeof nonce !== 'string') return { ok: false, reason: 'malformed' };\n  if (!/^\\d+$/.test(nonce) || nonce.length > NONCE_MAX_DIGITS) return { ok: false, reason: 'malformed' };\n  if (!secret) return { ok: false, reason: 'bad_signature' };\n  const body = parseProofOfWorkChallenge(challenge, secret);\n  if (!body) return { ok: false, reason: 'bad_signature' };\n  if ((opts.now ?? Date.now()) > body.exp) return { ok: false, reason: 'expired' };\n  if (opts.minDifficulty !== undefined && body.difficulty < clampDifficulty(opts.minDifficulty)) return { ok: false, reason: 'too_easy' };\n  if (leadingZeroBits(proofOfWorkHash(challenge, nonce)) < body.difficulty) return { ok: false, reason: 'insufficient_work' };\n  return { ok: true, key: challengeKey(challenge), expiresAt: body.exp, difficulty: body.difficulty };\n}\n\n/**\n * Find a nonce for `challenge` (tests, the CLI). Counts up from 0; throws\n * after `maxIterations` so a mistaken difficulty can't spin forever.\n */\nexport function solveProofOfWork(challenge: string, difficulty: number, opts: { maxIterations?: number } = {}): string {\n  const max = opts.maxIterations ?? 2 ** 32;\n  for (let i = 0; i < max; i++) {\n    const nonce = String(i);\n    if (leadingZeroBits(proofOfWorkHash(challenge, nonce)) >= difficulty) return nonce;\n  }\n  throw new Error(`No proof-of-work solution within ${max} iterations`);\n}\n"]}

package/lib/utils/response.d.ts

@@ -73,11 +73,10 @@ export declare function sendPaginatedNested<T>(res: Response, dataKey: string, d
  * Extracts PostgreSQL error codes, details, hints, and constraint names
  * from database errors for better error messages.
  *
- * Only a genuine Postgres error yields a `dbCode`. Any error object carrying a
- * `.code` used to be reported as one, so a transport failure (`ECONNRESET` when
- * the pooler drops out of the Service endpoints, say) logged as
- * `{"db":{"dbCode":"ECONNRESET"}}` and sent every reader hunting through clean
- * Postgres logs. The transport code is not lost — callers log the error message
+ * Only a genuine Postgres error yields a `dbCode`: reporting any `.code` as one
+ * would log a transport failure (`ECONNRESET` when the pooler drops out of the
+ * Service endpoints, say) as `{"db":{"dbCode":"ECONNRESET"}}` and send readers
+ * hunting through clean Postgres logs. The transport code is not lost — callers log the error message
  * itself alongside these details — it just stops claiming to be a DB fault.
  *
  * @param error - Error object from database operation
@@ -121,5 +120,16 @@ export interface PaginationParams {
     sortBy: string;
     sortOrder: 'asc' | 'desc';
 }
-/** Parse pagination/sort params from query string, clamping to safe defaults. */
+/** A parsed `?sortBy=&sortOrder=` (default: newest first). */
+export interface SortParams {
+    sortBy: string;
+    sortOrder: 'asc' | 'desc';
+}
+/** Parse `?sortBy=&sortOrder=`; defaults to `createdAt` descending. */
+export declare function parseSort(query: Record<string, unknown>): SortParams;
+/**
+ * The default list-route window + sort: {@link parsePage} with a page of 10
+ * (capped at `MAX_PAGE_LIMIT`, offset capped at `MAX_PAGE_OFFSET` — deep paging
+ * uses the cursor API) plus {@link parseSort}.
+ */
 export declare function parsePaginationParams(query: Record<string, unknown>): PaginationParams;

package/lib/utils/response.js

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 import { createLogger } from './logger.js';
 import { ErrorCode } from '../types/error-codes.js';
-import { MAX_PAGE_LIMIT, MAX_PAGE_OFFSET } from '../validation/common-schemas.js';
+import { MAX_PAGE_LIMIT } from '../validation/common-schemas.js';
+import { parsePage } from './params.js';
 const logger = createLogger('response');
 /**
  * Send a standardized success response.
@@ -149,11 +150,10 @@ const NODE_ERRNO_PATTERN = /^E/;
  * Extracts PostgreSQL error codes, details, hints, and constraint names
  * from database errors for better error messages.
  *
- * Only a genuine Postgres error yields a `dbCode`. Any error object carrying a
- * `.code` used to be reported as one, so a transport failure (`ECONNRESET` when
- * the pooler drops out of the Service endpoints, say) logged as
- * `{"db":{"dbCode":"ECONNRESET"}}` and sent every reader hunting through clean
- * Postgres logs. The transport code is not lost — callers log the error message
+ * Only a genuine Postgres error yields a `dbCode`: reporting any `.code` as one
+ * would log a transport failure (`ECONNRESET` when the pooler drops out of the
+ * Service endpoints, say) as `{"db":{"dbCode":"ECONNRESET"}}` and send readers
+ * hunting through clean Postgres logs. The transport code is not lost — callers log the error message
  * itself alongside these details — it just stops claiming to be a DB fault.
  *
  * @param error - Error object from database operation
@@ -235,15 +235,18 @@ export function sendBadRequest(res, message, code = ErrorCode.VALIDATION_ERROR)
 export function sendInternalError(res, message, details) {
     sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);
 }
-/** Parse pagination/sort params from query string, clamping to safe defaults. */
-export function parsePaginationParams(query) {
-    const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), MAX_PAGE_LIMIT);
-    // Clamp offset too — an unbounded offset forces Postgres to scan+discard huge row
-    // counts on hot list endpoints (a cheap DoS amplifier). Deep paging should use the
-    // cursor API. Ceiling = MAX_PAGE_OFFSET.
-    const offset = Math.min(Math.max(parseInt(String(query.offset), 10) || 0, 0), MAX_PAGE_OFFSET);
+/** Parse `?sortBy=&sortOrder=`; defaults to `createdAt` descending. */
+export function parseSort(query) {
     const sortBy = String(query.sortBy || 'createdAt');
     const sortOrder = String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';
-    return { limit, offset, sortBy, sortOrder };
+    return { sortBy, sortOrder };
+}
+/**
+ * The default list-route window + sort: {@link parsePage} with a page of 10
+ * (capped at `MAX_PAGE_LIMIT`, offset capped at `MAX_PAGE_OFFSET` — deep paging
+ * uses the cursor API) plus {@link parseSort}.
+ */
+export function parsePaginationParams(query) {
+    return { ...parsePage(query, { def: 10, max: MAX_PAGE_LIMIT }), ...parseSort(query) };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/utils/response.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\nimport { createLogger } from './logger.js';\nimport type { QuotaInfo } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { MAX_PAGE_LIMIT, MAX_PAGE_OFFSET } from '../validation/common-schemas.js';\n\nconst logger = createLogger('response');\n\n/**\n * Send a standardized success response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code (default: 200)\n * @param data - Response data\n * @param message - Optional success message\n *\n * @example\n * ```typescript\n * sendSuccess(res, 200, { plugin: pluginData });\n * sendSuccess(res, 201, { id: newId }, 'Resource created');\n * ```\n */\nexport function sendSuccess<T>(\n  res: Response,\n  statusCode: number = 200,\n  data?: T,\n  message?: string,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send success after headers already sent', { statusCode });\n    return;\n  }\n\n  const response: {\n    success: true;\n    statusCode: number;\n    data?: T;\n    message?: string;\n  } = {\n    success: true,\n    statusCode,\n  };\n\n  if (data !== undefined) {\n    response.data = data;\n  }\n\n  if (message) {\n    response.message = message;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a standardized error response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code\n * @param message - Error message\n * @param code - Error code from ErrorCode enum\n * @param details - Optional additional details\n *\n * @example\n * ```typescript\n * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);\n * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });\n * ```\n */\nexport function sendError(\n  res: Response,\n  statusCode: number,\n  message: string,\n  code?: ErrorCode | string,\n  details?: unknown,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send error after headers already sent', { statusCode, message });\n    return;\n  }\n\n  const response: {\n    success: false;\n    statusCode: number;\n    message: string;\n    code?: string;\n    details?: unknown;\n  } = {\n    success: false,\n    statusCode,\n    message,\n  };\n\n  if (code) {\n    response.code = code;\n  }\n\n  if (details !== undefined) {\n    response.details = details;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a quota exceeded error response.\n *\n * @param res - Express response object\n * @param quotaType - Type of quota exceeded\n * @param quota - Current quota information\n * @param resetAt - ISO timestamp when quota resets\n *\n * @example\n * ```typescript\n * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);\n * ```\n */\nexport function sendQuotaExceeded(\n  res: Response,\n  quotaType: string,\n  quota: QuotaInfo,\n  resetAt?: string,\n  message?: string,\n): void {\n  const resetDate = resetAt ? new Date(resetAt) : new Date();\n  const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));\n\n  // Guard like the sibling helpers: `setHeader` throws synchronously once the\n  // response has been sent, so skip the quota headers (and let `sendError` no-op)\n  // instead of crashing the handler on an already-committed response.\n  if (!res.headersSent) {\n    res.setHeader('Retry-After', resetIn);\n    res.setHeader('X-Quota-Limit', quota.limit);\n    res.setHeader('X-Quota-Used', quota.used);\n    res.setHeader('X-Quota-Remaining', Math.max(0, quota.remaining));\n\n    if (resetAt) {\n      res.setHeader('X-Quota-Reset', resetAt);\n    }\n  }\n\n  sendError(\n    res,\n    429,\n    message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`,\n    ErrorCode.QUOTA_EXCEEDED,\n    { quota },\n  );\n}\n\n/**\n * Send a paginated list response with the items nested under a named key.\n * Use when the API contract is `{ <key>: [...], pagination: {...} }`\n * (the dominant shape across api/* services).\n *\n * @example\n * ```typescript\n * sendPaginatedNested(res, 'pipelines', items, {\n *   total: 50, limit: 25, offset: 0, hasMore: true,\n * });\n * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }\n * ```\n */\nexport function sendPaginatedNested<T>(\n  res: Response,\n  dataKey: string,\n  data: T[],\n  options: {\n    total?: number;\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n    nextCursor?: string;\n    statusCode?: number;\n  },\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send paginated response after headers already sent');\n    return;\n  }\n  const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;\n  const pagination: Record<string, unknown> = { limit, offset, hasMore };\n  if (total !== undefined) pagination.total = total;\n  if (nextCursor) pagination.nextCursor = nextCursor;\n  res.status(statusCode).json({\n    success: true,\n    statusCode,\n    data: { [dataKey]: data, pagination },\n  });\n}\n\n/**\n * SQLSTATE: exactly five characters, digits and uppercase Latin letters\n * (e.g. `23505` unique_violation, `42601` syntax_error). Node's own socket and\n * DNS errors use the same `.code` property but spell it differently\n * (`ECONNRESET`, `ETIMEDOUT`, `ENOTFOUND`), which is what this tells apart.\n */\nconst SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;\n\n/**\n * Length alone is not enough: `EPIPE` and `E2BIG` are five uppercase characters\n * and would pass as SQLSTATEs. Every libuv/Node errno starts with `E`, and\n * Postgres defines no error class that does — its classes are 00-0Z, 20-2F,\n * 34-3F, 40-44, 53-58, 72, F0, HV, P0 and XX (see the server's errcodes.txt).\n * So a leading `E` settles it.\n */\nconst NODE_ERRNO_PATTERN = /^E/;\n\n/**\n * Extract database error details for logging/response.\n *\n * Extracts PostgreSQL error codes, details, hints, and constraint names\n * from database errors for better error messages.\n *\n * Only a genuine Postgres error yields a `dbCode`. Any error object carrying a\n * `.code` used to be reported as one, so a transport failure (`ECONNRESET` when\n * the pooler drops out of the Service endpoints, say) logged as\n * `{\"db\":{\"dbCode\":\"ECONNRESET\"}}` and sent every reader hunting through clean\n * Postgres logs. The transport code is not lost — callers log the error message\n * itself alongside these details — it just stops claiming to be a DB fault.\n *\n * @param error - Error object from database operation\n * @returns Object with extracted error details; `{}` when `error` is not a\n *   Postgres error (no SQLSTATE and none of the pg-specific fields)\n *\n * @example\n * ```typescript\n * try {\n *   await db.insert(plugins).values(newPlugin);\n * } catch (error) {\n *   const dbDetails = extractDbError(error);\n *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);\n * }\n * ```\n */\nexport function extractDbError(error: unknown): Record<string, unknown> {\n  if (!error || typeof error !== 'object') {\n    return {};\n  }\n\n  // Drizzle ORM wraps the original pg error in error.cause —\n  // check the cause first, then fall back to the error itself.\n  const err = error as Record<string, unknown>;\n  const source = (err.cause && typeof err.cause === 'object' ? err.cause : err) as Record<string, unknown>;\n  const details: Record<string, unknown> = {};\n\n  if (typeof source.code === 'string'\n    && SQLSTATE_PATTERN.test(source.code)\n    && !NODE_ERRNO_PATTERN.test(source.code)) {\n    details.dbCode = source.code;\n  }\n  if (source.detail) details.dbDetail = source.detail;\n  if (source.hint) details.dbHint = source.hint;\n  if (source.constraint) details.constraint = source.constraint;\n  if (source.table) details.table = source.table;\n  if (source.column) details.column = source.column;\n\n  return details;\n}\n\n// Convenience helpers (shared across plugin, pipeline, quota services)\n\n/**\n * Extract a human-readable message from an unknown catch value.\n *\n * Falls back beyond `.message` because several common Node errors carry an\n * EMPTY `.message`:\n *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`\n *    whose own message is blank — the cause lives in `.code` (e.g.\n *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;\n *  - raw socket `ErrnoException`s can likewise carry only a `.code`.\n * Without this, an unreachable internal service (e.g. compliance still\n * starting) produced blank per-item errors in bulk responses and `error:\"\"`\n * in logs — a silent black box. Order: message → code → joined sub-errors →\n * error name.\n */\nexport function errorMessage(error: unknown): string {\n  if (!(error instanceof Error)) return String(error);\n  if (error.message) return error.message;\n\n  const code = (error as { code?: string }).code;\n  if (code) return code;\n\n  const inner = (error as { errors?: unknown[] }).errors;\n  if (Array.isArray(inner) && inner.length > 0) {\n    const joined = inner.map(errorMessage).filter(Boolean).join('; ');\n    if (joined) return joined;\n  }\n\n  return error.name || 'Unknown error';\n}\n\n/** Send a 400 bad-request response. */\nexport function sendBadRequest(\n  res: Response,\n  message: string,\n  code: ErrorCode | string = ErrorCode.VALIDATION_ERROR,\n): void {\n  sendError(res, 400, message, code);\n}\n\n/** Send a 500 internal error response. */\nexport function sendInternalError(\n  res: Response,\n  message: string,\n  details?: Record<string, unknown>,\n): void {\n  sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);\n}\n\n// Pagination\n\n/** Common pagination + sorting parameters. */\nexport interface PaginationParams {\n  limit: number;\n  offset: number;\n  sortBy: string;\n  sortOrder: 'asc' | 'desc';\n}\n\n/** Parse pagination/sort params from query string, clamping to safe defaults. */\nexport function parsePaginationParams(query: Record<string, unknown>): PaginationParams {\n  const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), MAX_PAGE_LIMIT);\n  // Clamp offset too — an unbounded offset forces Postgres to scan+discard huge row\n  // counts on hot list endpoints (a cheap DoS amplifier). Deep paging should use the\n  // cursor API. Ceiling = MAX_PAGE_OFFSET.\n  const offset = Math.min(Math.max(parseInt(String(query.offset), 10) || 0, 0), MAX_PAGE_OFFSET);\n  const sortBy = String(query.sortBy || 'createdAt');\n  const sortOrder: 'asc' | 'desc' =\n    String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';\n\n  return { limit, offset, sortBy, sortOrder };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/utils/response.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\nimport { createLogger } from './logger.js';\nimport type { QuotaInfo } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { MAX_PAGE_LIMIT } from '../validation/common-schemas.js';\nimport { parsePage } from './params.js';\n\nconst logger = createLogger('response');\n\n/**\n * Send a standardized success response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code (default: 200)\n * @param data - Response data\n * @param message - Optional success message\n *\n * @example\n * ```typescript\n * sendSuccess(res, 200, { plugin: pluginData });\n * sendSuccess(res, 201, { id: newId }, 'Resource created');\n * ```\n */\nexport function sendSuccess<T>(\n  res: Response,\n  statusCode: number = 200,\n  data?: T,\n  message?: string,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send success after headers already sent', { statusCode });\n    return;\n  }\n\n  const response: {\n    success: true;\n    statusCode: number;\n    data?: T;\n    message?: string;\n  } = {\n    success: true,\n    statusCode,\n  };\n\n  if (data !== undefined) {\n    response.data = data;\n  }\n\n  if (message) {\n    response.message = message;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a standardized error response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code\n * @param message - Error message\n * @param code - Error code from ErrorCode enum\n * @param details - Optional additional details\n *\n * @example\n * ```typescript\n * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);\n * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });\n * ```\n */\nexport function sendError(\n  res: Response,\n  statusCode: number,\n  message: string,\n  code?: ErrorCode | string,\n  details?: unknown,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send error after headers already sent', { statusCode, message });\n    return;\n  }\n\n  const response: {\n    success: false;\n    statusCode: number;\n    message: string;\n    code?: string;\n    details?: unknown;\n  } = {\n    success: false,\n    statusCode,\n    message,\n  };\n\n  if (code) {\n    response.code = code;\n  }\n\n  if (details !== undefined) {\n    response.details = details;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a quota exceeded error response.\n *\n * @param res - Express response object\n * @param quotaType - Type of quota exceeded\n * @param quota - Current quota information\n * @param resetAt - ISO timestamp when quota resets\n *\n * @example\n * ```typescript\n * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);\n * ```\n */\nexport function sendQuotaExceeded(\n  res: Response,\n  quotaType: string,\n  quota: QuotaInfo,\n  resetAt?: string,\n  message?: string,\n): void {\n  const resetDate = resetAt ? new Date(resetAt) : new Date();\n  const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));\n\n  // Guard like the sibling helpers: `setHeader` throws synchronously once the\n  // response has been sent, so skip the quota headers (and let `sendError` no-op)\n  // instead of crashing the handler on an already-committed response.\n  if (!res.headersSent) {\n    res.setHeader('Retry-After', resetIn);\n    res.setHeader('X-Quota-Limit', quota.limit);\n    res.setHeader('X-Quota-Used', quota.used);\n    res.setHeader('X-Quota-Remaining', Math.max(0, quota.remaining));\n\n    if (resetAt) {\n      res.setHeader('X-Quota-Reset', resetAt);\n    }\n  }\n\n  sendError(\n    res,\n    429,\n    message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`,\n    ErrorCode.QUOTA_EXCEEDED,\n    { quota },\n  );\n}\n\n/**\n * Send a paginated list response with the items nested under a named key.\n * Use when the API contract is `{ <key>: [...], pagination: {...} }`\n * (the dominant shape across api/* services).\n *\n * @example\n * ```typescript\n * sendPaginatedNested(res, 'pipelines', items, {\n *   total: 50, limit: 25, offset: 0, hasMore: true,\n * });\n * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }\n * ```\n */\nexport function sendPaginatedNested<T>(\n  res: Response,\n  dataKey: string,\n  data: T[],\n  options: {\n    total?: number;\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n    nextCursor?: string;\n    statusCode?: number;\n  },\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send paginated response after headers already sent');\n    return;\n  }\n  const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;\n  const pagination: Record<string, unknown> = { limit, offset, hasMore };\n  if (total !== undefined) pagination.total = total;\n  if (nextCursor) pagination.nextCursor = nextCursor;\n  res.status(statusCode).json({\n    success: true,\n    statusCode,\n    data: { [dataKey]: data, pagination },\n  });\n}\n\n/**\n * SQLSTATE: exactly five characters, digits and uppercase Latin letters\n * (e.g. `23505` unique_violation, `42601` syntax_error). Node's own socket and\n * DNS errors use the same `.code` property but spell it differently\n * (`ECONNRESET`, `ETIMEDOUT`, `ENOTFOUND`), which is what this tells apart.\n */\nconst SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;\n\n/**\n * Length alone is not enough: `EPIPE` and `E2BIG` are five uppercase characters\n * and would pass as SQLSTATEs. Every libuv/Node errno starts with `E`, and\n * Postgres defines no error class that does — its classes are 00-0Z, 20-2F,\n * 34-3F, 40-44, 53-58, 72, F0, HV, P0 and XX (see the server's errcodes.txt).\n * So a leading `E` settles it.\n */\nconst NODE_ERRNO_PATTERN = /^E/;\n\n/**\n * Extract database error details for logging/response.\n *\n * Extracts PostgreSQL error codes, details, hints, and constraint names\n * from database errors for better error messages.\n *\n * Only a genuine Postgres error yields a `dbCode`: reporting any `.code` as one\n * would log a transport failure (`ECONNRESET` when the pooler drops out of the\n * Service endpoints, say) as `{\"db\":{\"dbCode\":\"ECONNRESET\"}}` and send readers\n * hunting through clean Postgres logs. The transport code is not lost — callers log the error message\n * itself alongside these details — it just stops claiming to be a DB fault.\n *\n * @param error - Error object from database operation\n * @returns Object with extracted error details; `{}` when `error` is not a\n *   Postgres error (no SQLSTATE and none of the pg-specific fields)\n *\n * @example\n * ```typescript\n * try {\n *   await db.insert(plugins).values(newPlugin);\n * } catch (error) {\n *   const dbDetails = extractDbError(error);\n *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);\n * }\n * ```\n */\nexport function extractDbError(error: unknown): Record<string, unknown> {\n  if (!error || typeof error !== 'object') {\n    return {};\n  }\n\n  // Drizzle ORM wraps the original pg error in error.cause —\n  // check the cause first, then fall back to the error itself.\n  const err = error as Record<string, unknown>;\n  const source = (err.cause && typeof err.cause === 'object' ? err.cause : err) as Record<string, unknown>;\n  const details: Record<string, unknown> = {};\n\n  if (typeof source.code === 'string'\n    && SQLSTATE_PATTERN.test(source.code)\n    && !NODE_ERRNO_PATTERN.test(source.code)) {\n    details.dbCode = source.code;\n  }\n  if (source.detail) details.dbDetail = source.detail;\n  if (source.hint) details.dbHint = source.hint;\n  if (source.constraint) details.constraint = source.constraint;\n  if (source.table) details.table = source.table;\n  if (source.column) details.column = source.column;\n\n  return details;\n}\n\n// Convenience helpers (shared across plugin, pipeline, quota services)\n\n/**\n * Extract a human-readable message from an unknown catch value.\n *\n * Falls back beyond `.message` because several common Node errors carry an\n * EMPTY `.message`:\n *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`\n *    whose own message is blank — the cause lives in `.code` (e.g.\n *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;\n *  - raw socket `ErrnoException`s can likewise carry only a `.code`.\n * Without this, an unreachable internal service (e.g. compliance still\n * starting) produced blank per-item errors in bulk responses and `error:\"\"`\n * in logs — a silent black box. Order: message → code → joined sub-errors →\n * error name.\n */\nexport function errorMessage(error: unknown): string {\n  if (!(error instanceof Error)) return String(error);\n  if (error.message) return error.message;\n\n  const code = (error as { code?: string }).code;\n  if (code) return code;\n\n  const inner = (error as { errors?: unknown[] }).errors;\n  if (Array.isArray(inner) && inner.length > 0) {\n    const joined = inner.map(errorMessage).filter(Boolean).join('; ');\n    if (joined) return joined;\n  }\n\n  return error.name || 'Unknown error';\n}\n\n/** Send a 400 bad-request response. */\nexport function sendBadRequest(\n  res: Response,\n  message: string,\n  code: ErrorCode | string = ErrorCode.VALIDATION_ERROR,\n): void {\n  sendError(res, 400, message, code);\n}\n\n/** Send a 500 internal error response. */\nexport function sendInternalError(\n  res: Response,\n  message: string,\n  details?: Record<string, unknown>,\n): void {\n  sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);\n}\n\n// Pagination\n\n/** Common pagination + sorting parameters. */\nexport interface PaginationParams {\n  limit: number;\n  offset: number;\n  sortBy: string;\n  sortOrder: 'asc' | 'desc';\n}\n\n/** A parsed `?sortBy=&sortOrder=` (default: newest first). */\nexport interface SortParams {\n  sortBy: string;\n  sortOrder: 'asc' | 'desc';\n}\n\n/** Parse `?sortBy=&sortOrder=`; defaults to `createdAt` descending. */\nexport function parseSort(query: Record<string, unknown>): SortParams {\n  const sortBy = String(query.sortBy || 'createdAt');\n  const sortOrder: 'asc' | 'desc' =\n    String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';\n  return { sortBy, sortOrder };\n}\n\n/**\n * The default list-route window + sort: {@link parsePage} with a page of 10\n * (capped at `MAX_PAGE_LIMIT`, offset capped at `MAX_PAGE_OFFSET` — deep paging\n * uses the cursor API) plus {@link parseSort}.\n */\nexport function parsePaginationParams(query: Record<string, unknown>): PaginationParams {\n  return { ...parsePage(query, { def: 10, max: MAX_PAGE_LIMIT }), ...parseSort(query) };\n}\n"]}