@pipeline-builder/api-core 4.1.19 → 4.1.21

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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

package/lib/utils/response.d.ts

@@ -46,16 +46,46 @@ export declare function sendError(res: Response, statusCode: number, message: st
  * ```
  */
 export declare function sendQuotaExceeded(res: Response, quotaType: string, quota: QuotaInfo, resetAt?: string, message?: string): void;
+/** The `pagination` envelope every list route returns. */
+export interface PaginationMeta {
+    total: number;
+    offset: number;
+    limit: number;
+    hasMore: boolean;
+}
+/**
+ * Build the `pagination` envelope for one page.
+ *
+ * `hasMore` is derived, never hand-computed: `offset + <rows on this page> <
+ * total` was THE most-repeated expression in the codebase, and a route that
+ * spells it slightly differently reports a phantom next page (or hides a real
+ * one) — a paging bug that only shows on the last page, where nobody looks.
+ *
+ * `returned` is the row count this page actually carries. It defaults to
+ * `limit` because a list route that doesn't say otherwise returns a full page;
+ * pass it for a route whose page can be shorter than its limit, and for an
+ * unpaged "everything" answer (which reports `limit = total`).
+ */
+export declare function paginationMeta(options: {
+    total: number;
+    offset: number;
+    limit: number;
+    returned?: number;
+}): PaginationMeta;
 /**
  * Send a paginated list response with the items nested under a named key.
  * Use when the API contract is `{ <key>: [...], pagination: {...} }`
  * (the dominant shape across api/* services).
  *
+ * `hasMore` is OPTIONAL and defaults to `offset + data.length < total` — the
+ * expression every caller used to write out by hand. Pass it only when the
+ * route knows something the row count does not (a cursor page, or a window
+ * fetched with `limit + 1` to peek ahead). Without a `total` there is nothing to
+ * derive from, so it falls back to "a cursor was issued".
+ *
  * @example
  * ```typescript
- * sendPaginatedNested(res, 'pipelines', items, {
- *   total: 50, limit: 25, offset: 0, hasMore: true,
- * });
+ * sendPaginatedNested(res, 'pipelines', items, { total: 50, limit: 25, offset: 0 });
  * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }
  * ```
  */
@@ -63,7 +93,7 @@ export declare function sendPaginatedNested<T>(res: Response, dataKey: string, d
     total?: number;
     limit: number;
     offset: number;
-    hasMore: boolean;
+    hasMore?: boolean;
     nextCursor?: string;
     statusCode?: number;
 }): void;

package/lib/utils/response.js

@@ -99,16 +99,37 @@ export function sendQuotaExceeded(res, quotaType, quota, resetAt, message) {
     }
     sendError(res, 429, message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`, ErrorCode.QUOTA_EXCEEDED, { quota });
 }
+/**
+ * Build the `pagination` envelope for one page.
+ *
+ * `hasMore` is derived, never hand-computed: `offset + <rows on this page> <
+ * total` was THE most-repeated expression in the codebase, and a route that
+ * spells it slightly differently reports a phantom next page (or hides a real
+ * one) — a paging bug that only shows on the last page, where nobody looks.
+ *
+ * `returned` is the row count this page actually carries. It defaults to
+ * `limit` because a list route that doesn't say otherwise returns a full page;
+ * pass it for a route whose page can be shorter than its limit, and for an
+ * unpaged "everything" answer (which reports `limit = total`).
+ */
+export function paginationMeta(options) {
+    const { total, offset, limit, returned } = options;
+    return { total, offset, limit, hasMore: offset + (returned ?? limit) < total };
+}
 /**
  * Send a paginated list response with the items nested under a named key.
  * Use when the API contract is `{ <key>: [...], pagination: {...} }`
  * (the dominant shape across api/* services).
  *
+ * `hasMore` is OPTIONAL and defaults to `offset + data.length < total` — the
+ * expression every caller used to write out by hand. Pass it only when the
+ * route knows something the row count does not (a cursor page, or a window
+ * fetched with `limit + 1` to peek ahead). Without a `total` there is nothing to
+ * derive from, so it falls back to "a cursor was issued".
+ *
  * @example
  * ```typescript
- * sendPaginatedNested(res, 'pipelines', items, {
- *   total: 50, limit: 25, offset: 0, hasMore: true,
- * });
+ * sendPaginatedNested(res, 'pipelines', items, { total: 50, limit: 25, offset: 0 });
  * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }
  * ```
  */
@@ -118,7 +139,11 @@ export function sendPaginatedNested(res, dataKey, data, options) {
         return;
     }
     const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;
-    const pagination = { limit, offset, hasMore };
+    const resolved = hasMore
+        ?? (total !== undefined
+            ? paginationMeta({ total, offset, limit, returned: data.length }).hasMore
+            : nextCursor !== undefined);
+    const pagination = { limit, offset, hasMore: resolved };
     if (total !== undefined)
         pagination.total = total;
     if (nextCursor)
@@ -249,4 +274,4 @@ export function parseSort(query) {
 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 } 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"]}
+//# 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/** The `pagination` envelope every list route returns. */\nexport interface PaginationMeta {\n  total: number;\n  offset: number;\n  limit: number;\n  hasMore: boolean;\n}\n\n/**\n * Build the `pagination` envelope for one page.\n *\n * `hasMore` is derived, never hand-computed: `offset + <rows on this page> <\n * total` was THE most-repeated expression in the codebase, and a route that\n * spells it slightly differently reports a phantom next page (or hides a real\n * one) — a paging bug that only shows on the last page, where nobody looks.\n *\n * `returned` is the row count this page actually carries. It defaults to\n * `limit` because a list route that doesn't say otherwise returns a full page;\n * pass it for a route whose page can be shorter than its limit, and for an\n * unpaged \"everything\" answer (which reports `limit = total`).\n */\nexport function paginationMeta(\n  options: { total: number; offset: number; limit: number; returned?: number },\n): PaginationMeta {\n  const { total, offset, limit, returned } = options;\n  return { total, offset, limit, hasMore: offset + (returned ?? limit) < total };\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 * `hasMore` is OPTIONAL and defaults to `offset + data.length < total` — the\n * expression every caller used to write out by hand. Pass it only when the\n * route knows something the row count does not (a cursor page, or a window\n * fetched with `limit + 1` to peek ahead). Without a `total` there is nothing to\n * derive from, so it falls back to \"a cursor was issued\".\n *\n * @example\n * ```typescript\n * sendPaginatedNested(res, 'pipelines', items, { total: 50, limit: 25, offset: 0 });\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 resolved = hasMore\n    ?? (total !== undefined\n      ? paginationMeta({ total, offset, limit, returned: data.length }).hasMore\n      : nextCursor !== undefined);\n  const pagination: Record<string, unknown> = { limit, offset, hasMore: resolved };\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"]}

package/lib/utils/sensitive-patterns.js

@@ -82,6 +82,22 @@ export const SENSITIVE_VALUE_PATTERNS = [
         re2: '\\bgh[pousr]_[A-Za-z0-9]{20,}\\b',
         replacement: REDACTED,
     },
+    {
+        // Fine-grained PAT: `github_pat_` + a 22-char id + `_` + a 59-char secret.
+        // The classic `gh[pousr]_` rule above does NOT cover it (`i` is not in that
+        // class), so without this one a fine-grained PAT reached Loki in the clear.
+        name: 'github_fine_grained_pat',
+        js: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+        re2: '\\bgithub_pat_[A-Za-z0-9_]{20,}\\b',
+        replacement: REDACTED,
+    },
+    {
+        // GitLab personal/project/group access tokens: `glpat-` + 20 chars.
+        name: 'gitlab_token',
+        js: /\bglpat-[A-Za-z0-9_-]{20,}\b/g,
+        re2: '\\bglpat-[A-Za-z0-9_-]{20,}\\b',
+        replacement: REDACTED,
+    },
     {
         name: 'slack_token',
         js: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g,
@@ -145,4 +161,4 @@ export function looksSensitive(input) {
         return false;
     return maskLine(input) !== input;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sensitive-patterns.js","sourceRoot":"","sources":["../../src/utils/sensitive-patterns.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,CAAC,MAAM,QAAQ,GAAG,YAAY,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,wHAAwH,CAAC;AAqB9J;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAqC;IACxE;QACE,2EAA2E;QAC3E,4EAA4E;QAC5E,IAAI,EAAE,iBAAiB;QACvB,EAAE,EAAE,2EAA2E;QAC/E,GAAG,EAAE,IAAI;QACT,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,wBAAwB;QAC9B,EAAE,EAAE,oCAAoC;QACxC,GAAG,EAAE,mCAAmC;QACxC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,KAAK;QACX,EAAE,EAAE,0DAA0D;QAC9D,GAAG,EAAE,2DAA2D;QAChE,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,cAAc;QACpB,EAAE,EAAE,iCAAiC;QACrC,GAAG,EAAE,oCAAoC;QACzC,WAAW,EAAE,UAAU,QAAQ,EAAE;KAClC;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,EAAE,EAAE,sDAAsD;QAC1D,GAAG,EAAE,qDAAqD;QAC1D,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,YAAY;QAClB,EAAE,EAAE,+CAA+C;QACnD,GAAG,EAAE,4CAA4C;QACjD,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,cAAc;QACpB,EAAE,EAAE,iCAAiC;QACrC,GAAG,EAAE,kCAAkC;QACvC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,aAAa;QACnB,EAAE,EAAE,mCAAmC;QACvC,GAAG,EAAE,oCAAoC;QACzC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,0EAA0E;QAC1E,IAAI,EAAE,iBAAiB;QACvB,EAAE,EAAE,oDAAoD;QACxD,GAAG,EAAE,mDAAmD;QACxD,WAAW,EAAE,KAAK,QAAQ,GAAG;KAC9B;IACD;QACE,wEAAwE;QACxE,IAAI,EAAE,kBAAkB;QACxB,EAAE,EAAE,sGAAsG;QAC1G,GAAG,EAAE,wGAAwG;QAC7G,WAAW,EAAE,KAAK,QAAQ,EAAE;KAC7B;IACD;QACE,iEAAiE;QACjE,kEAAkE;QAClE,2EAA2E;QAC3E,iEAAiE;QACjE,IAAI,EAAE,0BAA0B;QAChC,EAAE,EAAE,4HAA4H;QAChI,GAAG,EAAE,gIAAgI;QACrI,WAAW,EAAE,KAAK,QAAQ,EAAE;KAC7B;CACF,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,IAAI,GAAG,GAAG,KAAK,CAAC;IAChB,KAAK,MAAM,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,wBAAwB,EAAE,CAAC;QAC3D,2EAA2E;QAC3E,yEAAyE;QACzE,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC;QACjB,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,6BAA6B,CAAC,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AACnC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Single source of truth for \"what counts as sensitive\" across every masking\n * layer.\n *\n * Four layers consume this module (see `docs/observability-logs.md`):\n *\n *   L1  key-based, write-time   — winston `redactFormat` (metadata keys)\n *   L2  value-based, write-time — winston `maskFormat` (the message string)\n *   L3  value-based, ingest-time — promtail `replace` stages  ← AUTHORITATIVE\n *   L4  value-based, read-time  — platform's Loki client, before serving/export\n *\n * **L3 is the guarantee, not L4.** Read-time masking only masks the DISPLAY: the\n * secret is still in Loki and still matchable, so a user can search a candidate\n * value and learn from the hit that it is present, even though the line renders\n * `[REDACTED]`. Repeat that and search becomes an oracle. Masking therefore has\n * to happen before storage for anything the search path can match; L4 exists to\n * cover history written before L3 shipped, and as defense in depth.\n *\n * Because L3 runs inside promtail (Go / RE2) and L1/L2/L4 run in Node, each\n * pattern carries BOTH forms and a generator emits the promtail YAML from this\n * list — see `scripts/gen-promtail-masking.mjs`. Keeping ONE list is the point:\n * hand-synced copies drift.\n */\n\nimport { scrubAwsIdentifiersFromString } from './aws-scrub.js';\n\nexport const REDACTED = '[REDACTED]';\n\n/**\n * Keys whose VALUE must be masked wholesale, regardless of the value's shape.\n * Case-insensitive, anchored-substring match.\n *\n * Add a term only for leakage you've actually seen — over-redaction makes\n * incident debugging harder, and these logs are now a product surface.\n */\nexport const SENSITIVE_KEY_PATTERN = /password|secret|bearer|api[_-]?key|cookie|token|^auth(orization|_header)?$|stripe[_-]?(key|secret)|mongo(db)?[_-]?uri/i;\n\n/**\n * One secret-shaped value pattern.\n *\n * `js` is used by the Node-side layers. `re2` is the equivalent source for\n * promtail's `replace` stage — Go's RE2 has no lookaround, so a pattern that\n * needs it has `re2: null` and stays Node-only (L2/L4 still catch it; it just\n * isn't scrubbed before storage). `(?i)` is spelled inline for RE2 because\n * promtail takes a bare source string, while the JS form uses the `i` flag.\n */\nexport interface SensitiveValuePattern {\n  /** Stable identifier, used as the promtail stage comment. */\n  name: string;\n  js: RegExp;\n  /** RE2 source for promtail, or null when the pattern is JS-only. */\n  re2: string | null;\n  /** Replacement text. `$1` keeps a leading capture (e.g. the `?token=` prefix). */\n  replacement: string;\n}\n\n/**\n * Ordered — earlier patterns win, so the specific (a Stripe key) is masked\n * before the generic (a `secret=` assignment) can produce a messier result.\n */\nexport const SENSITIVE_VALUE_PATTERNS: readonly SensitiveValuePattern[] = [\n  {\n    // A PEM block spans lines, so promtail (which replaces per line) can't see\n    // the whole thing — JS-only. The BEGIN line alone is still a strong signal.\n    name: 'pem_private_key',\n    js: /-----BEGIN[A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END[A-Z ]*PRIVATE KEY-----/g,\n    re2: null,\n    replacement: REDACTED,\n  },\n  {\n    name: 'pem_private_key_header',\n    js: /-----BEGIN[A-Z ]*PRIVATE KEY-----/g,\n    re2: '-----BEGIN[A-Z ]*PRIVATE KEY-----',\n    replacement: REDACTED,\n  },\n  {\n    name: 'jwt',\n    js: /eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]*/g,\n    re2: 'eyJ[A-Za-z0-9_-]{8,}\\\\.[A-Za-z0-9_-]{8,}\\\\.[A-Za-z0-9_-]*',\n    replacement: REDACTED,\n  },\n  {\n    name: 'bearer_token',\n    js: /bearer\\s+[A-Za-z0-9._~+/-]+=*/gi,\n    re2: '(?i)bearer\\\\s+[A-Za-z0-9._~+/-]+=*',\n    replacement: `Bearer ${REDACTED}`,\n  },\n  {\n    name: 'aws_access_key_id',\n    js: /\\b(?:A3T[A-Z0-9]|AKIA|ASIA|ABIA|ACCA)[A-Z0-9]{16}\\b/g,\n    re2: '\\\\b(A3T[A-Z0-9]|AKIA|ASIA|ABIA|ACCA)[A-Z0-9]{16}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    name: 'stripe_key',\n    js: /\\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}\\b/g,\n    re2: '\\\\b(sk|rk)_(live|test)_[A-Za-z0-9]{10,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    name: 'github_token',\n    js: /\\bgh[pousr]_[A-Za-z0-9]{20,}\\b/g,\n    re2: '\\\\bgh[pousr]_[A-Za-z0-9]{20,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    name: 'slack_token',\n    js: /\\bxox[abprs]-[A-Za-z0-9-]{10,}\\b/g,\n    re2: '\\\\bxox[abprs]-[A-Za-z0-9-]{10,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    // `scheme://user:pass@host` — keep the scheme so the line stays readable.\n    name: 'url_credentials',\n    js: /([a-zA-Z][a-zA-Z0-9+.-]*:\\/\\/)[^:@/\\s]+:[^@/\\s]+@/g,\n    re2: '([a-zA-Z][a-zA-Z0-9+.-]*://)[^:@/\\\\s]+:[^@/\\\\s]+@',\n    replacement: `$1${REDACTED}@`,\n  },\n  {\n    // `?token=…` / `&api_key=…` in a URL. Keeps the parameter name visible.\n    name: 'url_secret_param',\n    js: /([?&](?:access[_-]?token|api[_-]?key|apikey|auth|password|secret|sig|signature|token)=)[^&\\s\"'<>]+/gi,\n    re2: '(?i)([?&](access[_-]?token|api[_-]?key|apikey|auth|password|secret|sig|signature|token)=)[^&\\\\s\"\\'<>]+',\n    replacement: `$1${REDACTED}`,\n  },\n  {\n    // `secret=…` / `\"password\": \"…\"` style assignments in free text.\n    // `&` is excluded from the value class so this can't run on after\n    // `url_secret_param` and swallow the rest of a query string — the URL rule\n    // has already masked those, and this one must not eat `&page=2`.\n    name: 'inline_secret_assignment',\n    js: /((?:aws_)?(?:secret_access_key|client_secret|api[_-]?key|apikey|password|passwd|secret|token)\"?\\s*[=:]\\s*\"?)[^\\s\"',;}&]+/gi,\n    re2: '(?i)(((aws_)?(secret_access_key|client_secret|api[_-]?key|apikey|password|passwd|secret|token))\"?\\\\s*[=:]\\\\s*\"?)[^\\\\s\"\\',;}&]+',\n    replacement: `$1${REDACTED}`,\n  },\n];\n\n/**\n * Mask secret-shaped values in a single string.\n *\n * Also scrubs AWS account identifiers via {@link scrubAwsIdentifiersFromString}\n * — a hard repo rule (an AWS account id must never be persisted or surfaced),\n * composed here rather than duplicated so the two rules can't drift.\n *\n * Non-throwing and allocation-light on the common path: strings with no match\n * come back by identity.\n */\nexport function maskLine(input: string): string {\n  if (!input) return input;\n  let out = input;\n  for (const { js, replacement } of SENSITIVE_VALUE_PATTERNS) {\n    // `js` carries the /g flag, so reset lastIndex — a shared RegExp object is\n    // stateful across calls and would otherwise skip matches intermittently.\n    js.lastIndex = 0;\n    out = out.replace(js, replacement);\n  }\n  return scrubAwsIdentifiersFromString(out);\n}\n\n/**\n * Does this string look like it CONTAINS a secret? Used to reject log-search\n * terms, closing the other end of the oracle described at the top of this file:\n * masking the result is pointless if the query itself can confirm a guess.\n */\nexport function looksSensitive(input: string): boolean {\n  if (!input) return false;\n  return maskLine(input) !== input;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sensitive-patterns.js","sourceRoot":"","sources":["../../src/utils/sensitive-patterns.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AAE/D,MAAM,CAAC,MAAM,QAAQ,GAAG,YAAY,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,wHAAwH,CAAC;AAqB9J;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAqC;IACxE;QACE,2EAA2E;QAC3E,4EAA4E;QAC5E,IAAI,EAAE,iBAAiB;QACvB,EAAE,EAAE,2EAA2E;QAC/E,GAAG,EAAE,IAAI;QACT,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,wBAAwB;QAC9B,EAAE,EAAE,oCAAoC;QACxC,GAAG,EAAE,mCAAmC;QACxC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,KAAK;QACX,EAAE,EAAE,0DAA0D;QAC9D,GAAG,EAAE,2DAA2D;QAChE,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,cAAc;QACpB,EAAE,EAAE,iCAAiC;QACrC,GAAG,EAAE,oCAAoC;QACzC,WAAW,EAAE,UAAU,QAAQ,EAAE;KAClC;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,EAAE,EAAE,sDAAsD;QAC1D,GAAG,EAAE,qDAAqD;QAC1D,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,YAAY;QAClB,EAAE,EAAE,+CAA+C;QACnD,GAAG,EAAE,4CAA4C;QACjD,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,cAAc;QACpB,EAAE,EAAE,iCAAiC;QACrC,GAAG,EAAE,kCAAkC;QACvC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,2EAA2E;QAC3E,4EAA4E;QAC5E,4EAA4E;QAC5E,IAAI,EAAE,yBAAyB;QAC/B,EAAE,EAAE,mCAAmC;QACvC,GAAG,EAAE,oCAAoC;QACzC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,oEAAoE;QACpE,IAAI,EAAE,cAAc;QACpB,EAAE,EAAE,+BAA+B;QACnC,GAAG,EAAE,gCAAgC;QACrC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,IAAI,EAAE,aAAa;QACnB,EAAE,EAAE,mCAAmC;QACvC,GAAG,EAAE,oCAAoC;QACzC,WAAW,EAAE,QAAQ;KACtB;IACD;QACE,0EAA0E;QAC1E,IAAI,EAAE,iBAAiB;QACvB,EAAE,EAAE,oDAAoD;QACxD,GAAG,EAAE,mDAAmD;QACxD,WAAW,EAAE,KAAK,QAAQ,GAAG;KAC9B;IACD;QACE,wEAAwE;QACxE,IAAI,EAAE,kBAAkB;QACxB,EAAE,EAAE,sGAAsG;QAC1G,GAAG,EAAE,wGAAwG;QAC7G,WAAW,EAAE,KAAK,QAAQ,EAAE;KAC7B;IACD;QACE,iEAAiE;QACjE,kEAAkE;QAClE,2EAA2E;QAC3E,iEAAiE;QACjE,IAAI,EAAE,0BAA0B;QAChC,EAAE,EAAE,4HAA4H;QAChI,GAAG,EAAE,gIAAgI;QACrI,WAAW,EAAE,KAAK,QAAQ,EAAE;KAC7B;CACF,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,IAAI,GAAG,GAAG,KAAK,CAAC;IAChB,KAAK,MAAM,EAAE,EAAE,EAAE,WAAW,EAAE,IAAI,wBAAwB,EAAE,CAAC;QAC3D,2EAA2E;QAC3E,yEAAyE;QACzE,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC;QACjB,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,6BAA6B,CAAC,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACzB,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;AACnC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Single source of truth for \"what counts as sensitive\" across every masking\n * layer.\n *\n * Four layers consume this module (see `docs/observability-logs.md`):\n *\n *   L1  key-based, write-time   — winston `redactFormat` (metadata keys)\n *   L2  value-based, write-time — winston `maskFormat` (the message string)\n *   L3  value-based, ingest-time — promtail `replace` stages  ← AUTHORITATIVE\n *   L4  value-based, read-time  — platform's Loki client, before serving/export\n *\n * **L3 is the guarantee, not L4.** Read-time masking only masks the DISPLAY: the\n * secret is still in Loki and still matchable, so a user can search a candidate\n * value and learn from the hit that it is present, even though the line renders\n * `[REDACTED]`. Repeat that and search becomes an oracle. Masking therefore has\n * to happen before storage for anything the search path can match; L4 exists to\n * cover history written before L3 shipped, and as defense in depth.\n *\n * Because L3 runs inside promtail (Go / RE2) and L1/L2/L4 run in Node, each\n * pattern carries BOTH forms and a generator emits the promtail YAML from this\n * list — see `scripts/gen-promtail-masking.mjs`. Keeping ONE list is the point:\n * hand-synced copies drift.\n */\n\nimport { scrubAwsIdentifiersFromString } from './aws-scrub.js';\n\nexport const REDACTED = '[REDACTED]';\n\n/**\n * Keys whose VALUE must be masked wholesale, regardless of the value's shape.\n * Case-insensitive, anchored-substring match.\n *\n * Add a term only for leakage you've actually seen — over-redaction makes\n * incident debugging harder, and these logs are now a product surface.\n */\nexport const SENSITIVE_KEY_PATTERN = /password|secret|bearer|api[_-]?key|cookie|token|^auth(orization|_header)?$|stripe[_-]?(key|secret)|mongo(db)?[_-]?uri/i;\n\n/**\n * One secret-shaped value pattern.\n *\n * `js` is used by the Node-side layers. `re2` is the equivalent source for\n * promtail's `replace` stage — Go's RE2 has no lookaround, so a pattern that\n * needs it has `re2: null` and stays Node-only (L2/L4 still catch it; it just\n * isn't scrubbed before storage). `(?i)` is spelled inline for RE2 because\n * promtail takes a bare source string, while the JS form uses the `i` flag.\n */\nexport interface SensitiveValuePattern {\n  /** Stable identifier, used as the promtail stage comment. */\n  name: string;\n  js: RegExp;\n  /** RE2 source for promtail, or null when the pattern is JS-only. */\n  re2: string | null;\n  /** Replacement text. `$1` keeps a leading capture (e.g. the `?token=` prefix). */\n  replacement: string;\n}\n\n/**\n * Ordered — earlier patterns win, so the specific (a Stripe key) is masked\n * before the generic (a `secret=` assignment) can produce a messier result.\n */\nexport const SENSITIVE_VALUE_PATTERNS: readonly SensitiveValuePattern[] = [\n  {\n    // A PEM block spans lines, so promtail (which replaces per line) can't see\n    // the whole thing — JS-only. The BEGIN line alone is still a strong signal.\n    name: 'pem_private_key',\n    js: /-----BEGIN[A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END[A-Z ]*PRIVATE KEY-----/g,\n    re2: null,\n    replacement: REDACTED,\n  },\n  {\n    name: 'pem_private_key_header',\n    js: /-----BEGIN[A-Z ]*PRIVATE KEY-----/g,\n    re2: '-----BEGIN[A-Z ]*PRIVATE KEY-----',\n    replacement: REDACTED,\n  },\n  {\n    name: 'jwt',\n    js: /eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]*/g,\n    re2: 'eyJ[A-Za-z0-9_-]{8,}\\\\.[A-Za-z0-9_-]{8,}\\\\.[A-Za-z0-9_-]*',\n    replacement: REDACTED,\n  },\n  {\n    name: 'bearer_token',\n    js: /bearer\\s+[A-Za-z0-9._~+/-]+=*/gi,\n    re2: '(?i)bearer\\\\s+[A-Za-z0-9._~+/-]+=*',\n    replacement: `Bearer ${REDACTED}`,\n  },\n  {\n    name: 'aws_access_key_id',\n    js: /\\b(?:A3T[A-Z0-9]|AKIA|ASIA|ABIA|ACCA)[A-Z0-9]{16}\\b/g,\n    re2: '\\\\b(A3T[A-Z0-9]|AKIA|ASIA|ABIA|ACCA)[A-Z0-9]{16}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    name: 'stripe_key',\n    js: /\\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{10,}\\b/g,\n    re2: '\\\\b(sk|rk)_(live|test)_[A-Za-z0-9]{10,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    name: 'github_token',\n    js: /\\bgh[pousr]_[A-Za-z0-9]{20,}\\b/g,\n    re2: '\\\\bgh[pousr]_[A-Za-z0-9]{20,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    // Fine-grained PAT: `github_pat_` + a 22-char id + `_` + a 59-char secret.\n    // The classic `gh[pousr]_` rule above does NOT cover it (`i` is not in that\n    // class), so without this one a fine-grained PAT reached Loki in the clear.\n    name: 'github_fine_grained_pat',\n    js: /\\bgithub_pat_[A-Za-z0-9_]{20,}\\b/g,\n    re2: '\\\\bgithub_pat_[A-Za-z0-9_]{20,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    // GitLab personal/project/group access tokens: `glpat-` + 20 chars.\n    name: 'gitlab_token',\n    js: /\\bglpat-[A-Za-z0-9_-]{20,}\\b/g,\n    re2: '\\\\bglpat-[A-Za-z0-9_-]{20,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    name: 'slack_token',\n    js: /\\bxox[abprs]-[A-Za-z0-9-]{10,}\\b/g,\n    re2: '\\\\bxox[abprs]-[A-Za-z0-9-]{10,}\\\\b',\n    replacement: REDACTED,\n  },\n  {\n    // `scheme://user:pass@host` — keep the scheme so the line stays readable.\n    name: 'url_credentials',\n    js: /([a-zA-Z][a-zA-Z0-9+.-]*:\\/\\/)[^:@/\\s]+:[^@/\\s]+@/g,\n    re2: '([a-zA-Z][a-zA-Z0-9+.-]*://)[^:@/\\\\s]+:[^@/\\\\s]+@',\n    replacement: `$1${REDACTED}@`,\n  },\n  {\n    // `?token=…` / `&api_key=…` in a URL. Keeps the parameter name visible.\n    name: 'url_secret_param',\n    js: /([?&](?:access[_-]?token|api[_-]?key|apikey|auth|password|secret|sig|signature|token)=)[^&\\s\"'<>]+/gi,\n    re2: '(?i)([?&](access[_-]?token|api[_-]?key|apikey|auth|password|secret|sig|signature|token)=)[^&\\\\s\"\\'<>]+',\n    replacement: `$1${REDACTED}`,\n  },\n  {\n    // `secret=…` / `\"password\": \"…\"` style assignments in free text.\n    // `&` is excluded from the value class so this can't run on after\n    // `url_secret_param` and swallow the rest of a query string — the URL rule\n    // has already masked those, and this one must not eat `&page=2`.\n    name: 'inline_secret_assignment',\n    js: /((?:aws_)?(?:secret_access_key|client_secret|api[_-]?key|apikey|password|passwd|secret|token)\"?\\s*[=:]\\s*\"?)[^\\s\"',;}&]+/gi,\n    re2: '(?i)(((aws_)?(secret_access_key|client_secret|api[_-]?key|apikey|password|passwd|secret|token))\"?\\\\s*[=:]\\\\s*\"?)[^\\\\s\"\\',;}&]+',\n    replacement: `$1${REDACTED}`,\n  },\n];\n\n/**\n * Mask secret-shaped values in a single string.\n *\n * Also scrubs AWS account identifiers via {@link scrubAwsIdentifiersFromString}\n * — a hard repo rule (an AWS account id must never be persisted or surfaced),\n * composed here rather than duplicated so the two rules can't drift.\n *\n * Non-throwing and allocation-light on the common path: strings with no match\n * come back by identity.\n */\nexport function maskLine(input: string): string {\n  if (!input) return input;\n  let out = input;\n  for (const { js, replacement } of SENSITIVE_VALUE_PATTERNS) {\n    // `js` carries the /g flag, so reset lastIndex — a shared RegExp object is\n    // stateful across calls and would otherwise skip matches intermittently.\n    js.lastIndex = 0;\n    out = out.replace(js, replacement);\n  }\n  return scrubAwsIdentifiersFromString(out);\n}\n\n/**\n * Does this string look like it CONTAINS a secret? Used to reject log-search\n * terms, closing the other end of the oracle described at the top of this file:\n * masking the result is pointless if the query itself can confirm a guess.\n */\nexport function looksSensitive(input: string): boolean {\n  if (!input) return false;\n  return maskLine(input) !== input;\n}\n"]}

package/lib/validation/index.d.ts

@@ -2,11 +2,11 @@ export { VisibilitySchema, MAX_PAGE_LIMIT, DEFAULT_PAGE_LIMIT, UUIDPrefixSchema,
 export * from './pipeline-schemas.js';
 export { PipelineTemplateFilterSchema, PipelineTemplateCreateSchema, PipelineTemplateUpdateSchema, InstantiateTemplateSchema, } from './pipeline-template-schemas.js';
 export * from './plugin-schemas.js';
-export { isAllowedSpdxId, projectUrlProblem, validateCatalogField, findContractKeys, contractKeysMessage, SPDX_LICENSE_IDS, URL_SHORTENER_HOSTS, ICON_KEY_PATTERN, PluginCatalogEditsSchema, type PluginCatalogEdits, PLUGIN_CONTRACT_FIELDS, } from './plugin-catalog-metadata.js';
+export { isAllowedSpdxId, projectUrlProblem, validateCatalogField, findContractKeys, contractKeysMessage, ICON_KEY_PATTERN, PluginCatalogEditsSchema, type PluginCatalogEdits, PLUGIN_CONTRACT_FIELDS, } from './plugin-catalog-metadata.js';
 export { isAllowedAttachmentType, MessageTypeSchema, MessagePrioritySchema, MessageFilterSchema, MESSAGE_ATTACHMENT_MAX_BYTES, MESSAGE_ATTACHMENT_ALLOWED_MIME, MessageCreateSchema, MessageReplySchema, MessageEditSchema, } from './message-schemas.js';
 export * from './ai-schemas.js';
 export { validate, validateQuery, validateBody, } from './middleware.js';
-export { isValidEgressHost, checkPluginSpec, checkPluginConfig, pluginSpecRequiredFieldsProblem, PLUGIN_TYPES, PLUGIN_COMPUTE_TYPES, PLUGIN_FAILURE_BEHAVIORS, PLUGIN_BUILD_TYPES, type PluginBuildType, PLUGIN_NAME_PATTERN, PLUGIN_VERSION_PATTERN, EGRESS_MAX_HOSTS, type PluginSpecInput, type PackageCheck, } from './plugin-spec-schema.js';
+export { isValidEgressHost, checkPluginSpec, checkPluginConfig, pluginSpecRequiredFieldsProblem, PLUGIN_TYPES, PLUGIN_COMPUTE_TYPES, type PluginBuildType, PLUGIN_NAME_PATTERN, PLUGIN_VERSION_PATTERN, type PluginSpecInput, type PackageCheck, } from './plugin-spec-schema.js';
 export { stripInlineMarkdown, readmeTitle, readmeFirstParagraph, firstSentence, detectCatalogMetadata, resolveCatalogMetadata, acceptAllCatalogMetadata, parseCatalogEdits, parseCatalogEditsPart, type DetectedField, type CatalogSpecFields, type ResolvedCatalog, } from './plugin-catalog-detect.js';
 export { parseLabelArgs, parseDockerfile, OCI_LABELS, } from './dockerfile-static.js';
 export { isPluginTemplatableField, checkPluginTemplates, formatPluginTemplateIssue, PLUGIN_TEMPLATE_SCOPE_ROOTS, type PluginTemplateEngine, type PluginTemplateIssue, } from './plugin-template-contract.js';

package/lib/validation/index.js

@@ -4,11 +4,11 @@ export { VisibilitySchema, MAX_PAGE_LIMIT, DEFAULT_PAGE_LIMIT, UUIDPrefixSchema,
 export * from './pipeline-schemas.js';
 export { PipelineTemplateFilterSchema, PipelineTemplateCreateSchema, PipelineTemplateUpdateSchema, InstantiateTemplateSchema, } from './pipeline-template-schemas.js';
 export * from './plugin-schemas.js';
-export { isAllowedSpdxId, projectUrlProblem, validateCatalogField, findContractKeys, contractKeysMessage, SPDX_LICENSE_IDS, URL_SHORTENER_HOSTS, ICON_KEY_PATTERN, PluginCatalogEditsSchema, PLUGIN_CONTRACT_FIELDS, } from './plugin-catalog-metadata.js';
+export { isAllowedSpdxId, projectUrlProblem, validateCatalogField, findContractKeys, contractKeysMessage, ICON_KEY_PATTERN, PluginCatalogEditsSchema, PLUGIN_CONTRACT_FIELDS, } from './plugin-catalog-metadata.js';
 export { isAllowedAttachmentType, MessageTypeSchema, MessagePrioritySchema, MessageFilterSchema, MESSAGE_ATTACHMENT_MAX_BYTES, MESSAGE_ATTACHMENT_ALLOWED_MIME, MessageCreateSchema, MessageReplySchema, MessageEditSchema, } from './message-schemas.js';
 export * from './ai-schemas.js';
 export { validate, validateQuery, validateBody, } from './middleware.js';
-export { isValidEgressHost, checkPluginSpec, checkPluginConfig, pluginSpecRequiredFieldsProblem, PLUGIN_TYPES, PLUGIN_COMPUTE_TYPES, PLUGIN_FAILURE_BEHAVIORS, PLUGIN_BUILD_TYPES, PLUGIN_NAME_PATTERN, PLUGIN_VERSION_PATTERN, EGRESS_MAX_HOSTS, } from './plugin-spec-schema.js';
+export { isValidEgressHost, checkPluginSpec, checkPluginConfig, pluginSpecRequiredFieldsProblem, PLUGIN_TYPES, PLUGIN_COMPUTE_TYPES, PLUGIN_NAME_PATTERN, PLUGIN_VERSION_PATTERN, } from './plugin-spec-schema.js';
 export { stripInlineMarkdown, readmeTitle, readmeFirstParagraph, firstSentence, detectCatalogMetadata, resolveCatalogMetadata, acceptAllCatalogMetadata, parseCatalogEdits, parseCatalogEditsPart, } from './plugin-catalog-detect.js';
 export { parseLabelArgs, parseDockerfile, OCI_LABELS, } from './dockerfile-static.js';
 export { isPluginTemplatableField, checkPluginTemplates, formatPluginTemplateIssue, PLUGIN_TEMPLATE_SCOPE_ROOTS, } from './plugin-template-contract.js';
@@ -16,4 +16,4 @@ export { lintPluginDockerfile, lintPluginSpec } from './plugin-lint.js';
 export * from './plugin-base-images.js';
 export { shannonEntropy, scanPluginSourceHeuristics, blockingHeuristics, HEURISTICS_MAX_FILE_BYTES, HEURISTICS_MAX_FINDINGS, } from './plugin-heuristics.js';
 export { findConfusableName } from './plugin-name-confusable.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -25,6 +25,7 @@
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "9.1.0",
     "@aws-sdk/client-kms": "3.1136.0",
+    "@aws-sdk/client-s3": "3.1136.0",
     "@aws-sdk/client-sts": "3.1136.0",
     "@aws-sdk/credential-providers": "3.1136.0",
     "express": "5.2.1",
@@ -100,10 +101,13 @@
       ],
       "plugin-catalog": [
         "lib/types/plugin-catalog.d.ts"
+      ],
+      "ask-proposals": [
+        "lib/types/ask-proposals.d.ts"
       ]
     }
   },
-  "version": "4.1.19",
+  "version": "4.1.21",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },
@@ -225,10 +229,18 @@
       "types": "./lib/types/plugin-catalog.d.ts",
       "default": "./lib/types/plugin-catalog.js"
     },
+    "./ask-proposals": {
+      "types": "./lib/types/ask-proposals.d.ts",
+      "default": "./lib/types/ask-proposals.js"
+    },
     "./testing": {
       "types": "./lib/testing/index.d.ts",
       "default": "./lib/testing/index.js"
     },
+    "./s3": {
+      "types": "./lib/services/s3-client.d.ts",
+      "default": "./lib/services/s3-client.js"
+    },
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },