@pipeline-builder/api-core 4.1.12 → 4.1.14

package/lib/middleware/system-org.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The system tenant's well-known identity.
+ */
+/**
+ * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT
+ * the string 'system'). This is the single knob every service resolves the
+ * system tenant through; override via the `SYSTEM_ORG_ID` env for alternate
+ * installs. The system org's human identifier stays the slug/name 'system'
+ * (see {@link SYSTEM_ORG_SLUG}); only its `_id` is this ObjectId.
+ */
+export declare const SYSTEM_ORG_ID: string;
+/** The system org's well-known slug/name (the human identifier; its `_id` is {@link SYSTEM_ORG_ID}). */
+export declare const SYSTEM_ORG_SLUG = "system";
+/**
+ * Check if an orgId or orgName/slug matches the system org. Use this instead of
+ * comparing directly: the id is now an ObjectId ({@link SYSTEM_ORG_ID}) while the
+ * name/slug is 'system' ({@link SYSTEM_ORG_SLUG}), so the two are compared against
+ * their respective canonical values.
+ */
+export declare function isSystemOrgId(orgId?: string, orgName?: string): boolean;

package/lib/middleware/system-org.js

@@ -0,0 +1,25 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The system tenant's well-known identity.
+ */
+/**
+ * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT
+ * the string 'system'). This is the single knob every service resolves the
+ * system tenant through; override via the `SYSTEM_ORG_ID` env for alternate
+ * installs. The system org's human identifier stays the slug/name 'system'
+ * (see {@link SYSTEM_ORG_SLUG}); only its `_id` is this ObjectId.
+ */
+export const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || '000000000000000000000001').toLowerCase();
+/** The system org's well-known slug/name (the human identifier; its `_id` is {@link SYSTEM_ORG_ID}). */
+export const SYSTEM_ORG_SLUG = 'system';
+/**
+ * Check if an orgId or orgName/slug matches the system org. Use this instead of
+ * comparing directly: the id is now an ObjectId ({@link SYSTEM_ORG_ID}) while the
+ * name/slug is 'system' ({@link SYSTEM_ORG_SLUG}), so the two are compared against
+ * their respective canonical values.
+ */
+export function isSystemOrgId(orgId, orgName) {
+    return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_SLUG;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/plugin-routes.js

@@ -3,7 +3,71 @@
 import { registry } from '../registry.js';
 const tags = ['Plugins'];
 const auth = [{ bearerAuth: [] }];
+const publicTags = ['Public plugin directory'];
 export function registerPluginRoutes() {
+    // -- Anonymous public directory. No auth; nginx serves
+    //    these at /api/public/* with credentials stripped. Off → every route 404s.
+    registry.registerPath({
+        method: 'get',
+        path: '/public/plugins',
+        summary: 'Search the public plugin directory',
+        description: 'Anonymous search and browse over publicly listed plugins, with facets. Query: `q` (full text + '
+            + 'typo-tolerant name match), `category`, `tier` (official | verified | community | unverified), `license`, '
+            + '`computeType`, `needsSecrets` (true | false), `minRating` (1-5), `sort` (relevance | rating | installs | '
+            + 'updated | name), `cursor` (from `nextCursor`), `limit` (capped at 60). Rate limited per client IP; '
+            + 'publicly cacheable.',
+        tags: publicTags,
+        security: [],
+        responses: {
+            200: { description: '`{ items, facets, total, nextCursor }`' },
+            400: { description: 'Invalid query parameter' },
+            404: { description: 'The public directory is turned off' },
+            429: { description: 'Rate limited' },
+        },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/public/plugins/categories',
+        summary: 'Public directory categories',
+        description: 'Every category with its live listing count and top listings.',
+        tags: publicTags,
+        security: [],
+        responses: { 200: { description: '`{ categories }`' }, 404: { description: 'The public directory is turned off' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/public/plugins/sitemap',
+        summary: 'Public directory sitemap entries',
+        description: 'Every public listing\'s publisher, name and last update, for building `/sitemap.xml`.',
+        tags: publicTags,
+        security: [],
+        responses: { 200: { description: '`{ entries }`' }, 404: { description: 'The public directory is turned off' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/public/plugins/{publisher}/{name}',
+        summary: 'Public plugin page data',
+        description: 'One public listing: card fields, README (sanitized HTML), versions, configuration contract, '
+            + 'supply-chain facts, advisories and rating distribution. Unknown, paused or suspended listings are 404.',
+        tags: publicTags,
+        security: [],
+        responses: { 200: { description: '`{ listing }`' }, 404: { description: 'Not a public listing' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/public/plugins/{publisher}/{name}/versions/{version}/sbom',
+        summary: 'Download a listed version\'s SBOM',
+        description: 'The SPDX JSON SBOM of a listed, non-yanked version\'s public image, read from its signed '
+            + 'attestation. Anonymous; publicly cacheable.',
+        tags: publicTags,
+        security: [],
+        responses: {
+            200: { description: 'SPDX JSON document (application/spdx+json, served as an attachment)' },
+            404: { description: 'Not a listed version (unknown, yanked or paused)' },
+            409: { description: 'IMAGE_VERIFICATION_FAILED — no SBOM attestation verified' },
+            503: { description: 'Too many SBOM verifications in progress; retry after `Retry-After` seconds' },
+        },
+    });
     registry.registerPath({
         method: 'get',
         path: '/plugins',
@@ -19,11 +83,13 @@ export function registerPluginRoutes() {
         summary: 'Find a single plugin',
         description: 'Find a single plugin matching the query filters. For a plugin that runs on its own image, '
             + 'the image\'s cosign signature is verified first; `imageDigest` in the response is the verified digest '
-            + 'pipelines pin CodeBuild to.',
+            + 'pipelines pin CodeBuild to. `name` matches exactly. A yanked version resolves only when pinned exactly '
+            + '(by `id` or an exact `version`). The answer is `{ plugin, warnings }`: `warnings` lists '
+            + '`PLUGIN_DEPRECATED` / `PLUGIN_YANKED` notices ({ code, message }) for the resolved version.',
         tags,
         security: auth,
         responses: {
-            200: { description: 'Plugin found' },
+            200: { description: '`{ plugin, warnings }`' },
             404: { description: 'Not found' },
             409: { description: 'IMAGE_VERIFICATION_FAILED — the plugin image has no signed digest, or its signature did not verify' },
         },
@@ -33,11 +99,12 @@ export function registerPluginRoutes() {
         path: '/plugins/lookup',
         summary: 'Resolve a single plugin (synth)',
         description: 'Same as `GET /plugins/find` with the filter in the body — the endpoint pipeline synth resolves '
-            + 'plugins through. Verifies the plugin image signature before returning it.',
+            + 'plugins through. Verifies the plugin image signature before returning it. Synth prints the answer\'s '
+            + '`warnings` (deprecated / yanked-but-pinned versions).',
         tags,
         security: auth,
         responses: {
-            200: { description: 'Plugin found' },
+            200: { description: '`{ plugin, warnings }`' },
             400: { description: 'Missing or invalid filter' },
             404: { description: 'Not found' },
             409: { description: 'IMAGE_VERIFICATION_FAILED — the plugin image has no signed digest, or its signature did not verify' },
@@ -69,27 +136,83 @@ export function registerPluginRoutes() {
         method: 'post',
         path: '/plugins',
         summary: 'Upload a plugin',
-        description: 'Upload a plugin ZIP file with spec. Builds Docker image and saves to database.',
+        description: 'Upload a plugin ZIP (multipart part `plugin`). Builds, signs and scans the image, then saves the '
+            + 'version. Optional parts: `visibility`, and `metadata` — a JSON object of catalog edits (summary, '
+            + 'description, displayName, category, keywords, license, homepageUrl, sourceUrl, documentationUrl, icon, '
+            + 'changelog, readme; `null` clears a field). When `metadata` is absent every value detected from the '
+            + 'package is accepted. Execution-contract keys in `metadata` are refused with 400.',
         tags,
         security: auth,
         responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },
     });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins/inspect',
+        summary: 'Inspect a plugin zip (dry run)',
+        description: 'Parses a plugin ZIP (multipart part `plugin`) without building or storing anything and returns '
+            + 'every descriptive catalog field detected from the package: `{ plugin, fields: [{ field, value, source, '
+            + 'error }] }`. `source` is spec | readme | dockerfile | derived (or null when nothing was found); a value '
+            + 'that fails validation comes back blank with its `error`. Same zip bounds as upload; rate limited; '
+            + 'requires plugins:write.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Detected catalog fields' }, 400: { description: 'Invalid zip or spec' }, 429: { description: 'Rate limited' } },
+    });
     registry.registerPath({
         method: 'put',
         path: '/plugins/{id}',
         summary: 'Update a plugin',
+        description: 'Edit a version\'s descriptive catalog fields (summary, description, displayName, category, '
+            + 'keywords, license, links, icon, changelog, readme) and its operational flags (isActive, isDefault, '
+            + 'visibility, lifecycle, criticality, labels, links, owner). Execution-contract keys (commands, env, '
+            + 'secrets, computeType, …) are refused with 400: they change only with a new version. A version that is '
+            + 'frozen by a publish request or listed has its catalog details frozen (409).',
         tags,
         security: auth,
-        responses: { 200: { description: 'Plugin updated' }, 404: { description: 'Not found' } },
+        responses: {
+            200: { description: 'Plugin updated' },
+            400: { description: 'Validation error, or an execution-contract key' },
+            404: { description: 'Not found' },
+            409: { description: 'PLUGIN_VERSION_FROZEN — catalog details are frozen with the version' },
+        },
     });
     registry.registerPath({
         method: 'delete',
         path: '/plugins/{id}',
-        summary: 'Delete a plugin',
-        description: 'Soft-delete a plugin by setting isActive to false.',
+        summary: 'Delete a plugin version',
+        description: 'Soft-delete a version. A version used by the org\'s pipelines or published to a listing is refused '
+            + 'unless `?force=true`, which requires a step-up token (`X-Step-Up-Token`). A version referenced by a pending '
+            + 'publish request is never deletable. Deleting the default promotes the next default; the version\'s '
+            + '`plugins` quota slot is refunded while its quota period is current.',
+        tags,
+        security: auth,
+        responses: {
+            200: { description: 'Plugin deleted (`promotedDefault` when a new default was chosen)' },
+            401: { description: 'STEP_UP_REQUIRED — force delete without a step-up token' },
+            404: { description: 'Not found' },
+            409: { description: 'PLUGIN_VERSION_IN_USE / PLUGIN_VERSION_FROZEN' },
+        },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins/{id}/deprecate',
+        summary: 'Deprecate a plugin version',
+        description: 'Body `{ deprecated?: boolean (default true), message?: string }`. A deprecated version keeps '
+            + 'resolving with a warning, and is no longer offered by AI plugin selection.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Updated version' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/plugins/{id}/yank',
+        summary: 'Yank a plugin version',
+        description: 'Body `{ reason }`. A yanked version stops resolving for ranges, `latest` and the default; an '
+            + 'exact pin still resolves with a warning. Yanking the default promotes the next one. A version published '
+            + 'to the ecosystem is yanked through a publish request instead (409).',
         tags,
         security: auth,
-        responses: { 200: { description: 'Plugin deleted' }, 404: { description: 'Not found' } },
+        responses: { 200: { description: 'Yanked version (`promotedDefault` when a new default was chosen)' }, 404: { description: 'Not found' }, 409: { description: 'PLUGIN_VERSION_FROZEN' } },
     });
     registry.registerPath({
         method: 'get',
@@ -128,4 +251,4 @@ export function registerPluginRoutes() {
         responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 403: { description: 'Admin required' }, 429: { description: 'Quota exceeded' } },
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/plugin-routes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Plugins'];\nconst auth = [{ bearerAuth: [] }];\n\nexport function registerPluginRoutes(): void {\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins',\n    summary: 'List plugins',\n    description: 'List plugins with pagination, filtering, and sorting.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of plugins' }, 401: { description: 'Unauthorized' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/find',\n    summary: 'Find a single plugin',\n    description: 'Find a single plugin matching the query filters. For a plugin that runs on its own image, '\n      + 'the image\\'s cosign signature is verified first; `imageDigest` in the response is the verified digest '\n      + 'pipelines pin CodeBuild to.',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: 'Plugin found' },\n      404: { description: 'Not found' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — the plugin image has no signed digest, or its signature did not verify' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/lookup',\n    summary: 'Resolve a single plugin (synth)',\n    description: 'Same as `GET /plugins/find` with the filter in the body — the endpoint pipeline synth resolves '\n      + 'plugins through. Verifies the plugin image signature before returning it.',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: 'Plugin found' },\n      400: { description: 'Missing or invalid filter' },\n      404: { description: 'Not found' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — the plugin image has no signed digest, or its signature did not verify' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/{id}/sbom',\n    summary: 'Download a plugin image SBOM',\n    description: 'The SPDX JSON SBOM of the plugin image, read from its signed in-toto attestation — so the '\n      + 'document returned is exactly what the platform generated and signed at build time.',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: 'SPDX JSON document (application/spdx+json, served as an attachment)' },\n      404: { description: 'Plugin not found, or the plugin has no image' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — no SBOM attestation verified against the plugin-signing key' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/{id}',\n    summary: 'Get plugin by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins',\n    summary: 'Upload a plugin',\n    description: 'Upload a plugin ZIP file with spec. Builds Docker image and saves to database.',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/plugins/{id}',\n    summary: 'Update a plugin',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin updated' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/plugins/{id}',\n    summary: 'Delete a plugin',\n    description: 'Soft-delete a plugin by setting isActive to false.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin deleted' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/providers',\n    summary: 'List AI providers',\n    description: 'List AI providers configured for plugin generation.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of available AI providers with models' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/generate',\n    summary: 'Generate plugin via AI',\n    description: 'Generate a plugin configuration and Dockerfile from a natural language prompt.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Generated plugin configuration and Dockerfile' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/generate/stream',\n    summary: 'Stream plugin generation via AI',\n    description: 'Generate plugin configuration from a natural language prompt. Streams partial results as SSE events.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'SSE event stream of partial plugin objects' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/deploy-generated',\n    summary: 'Deploy AI-generated plugin',\n    description: 'Build Docker image from AI-generated Dockerfile and save plugin to database. Requires admin.',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 403: { description: 'Admin required' }, 429: { description: 'Quota exceeded' } },\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-routes.js","sourceRoot":"","sources":["../../../src/openapi/routes/plugin-routes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { registry } from '../registry.js';\n\nconst tags = ['Plugins'];\nconst auth = [{ bearerAuth: [] }];\n\nconst publicTags = ['Public plugin directory'];\n\nexport function registerPluginRoutes(): void {\n  // -- Anonymous public directory. No auth; nginx serves\n  //    these at /api/public/* with credentials stripped. Off → every route 404s.\n  registry.registerPath({\n    method: 'get',\n    path: '/public/plugins',\n    summary: 'Search the public plugin directory',\n    description: 'Anonymous search and browse over publicly listed plugins, with facets. Query: `q` (full text + '\n      + 'typo-tolerant name match), `category`, `tier` (official | verified | community | unverified), `license`, '\n      + '`computeType`, `needsSecrets` (true | false), `minRating` (1-5), `sort` (relevance | rating | installs | '\n      + 'updated | name), `cursor` (from `nextCursor`), `limit` (capped at 60). Rate limited per client IP; '\n      + 'publicly cacheable.',\n    tags: publicTags,\n    security: [],\n    responses: {\n      200: { description: '`{ items, facets, total, nextCursor }`' },\n      400: { description: 'Invalid query parameter' },\n      404: { description: 'The public directory is turned off' },\n      429: { description: 'Rate limited' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/public/plugins/categories',\n    summary: 'Public directory categories',\n    description: 'Every category with its live listing count and top listings.',\n    tags: publicTags,\n    security: [],\n    responses: { 200: { description: '`{ categories }`' }, 404: { description: 'The public directory is turned off' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/public/plugins/sitemap',\n    summary: 'Public directory sitemap entries',\n    description: 'Every public listing\\'s publisher, name and last update, for building `/sitemap.xml`.',\n    tags: publicTags,\n    security: [],\n    responses: { 200: { description: '`{ entries }`' }, 404: { description: 'The public directory is turned off' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/public/plugins/{publisher}/{name}',\n    summary: 'Public plugin page data',\n    description: 'One public listing: card fields, README (sanitized HTML), versions, configuration contract, '\n      + 'supply-chain facts, advisories and rating distribution. Unknown, paused or suspended listings are 404.',\n    tags: publicTags,\n    security: [],\n    responses: { 200: { description: '`{ listing }`' }, 404: { description: 'Not a public listing' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/public/plugins/{publisher}/{name}/versions/{version}/sbom',\n    summary: 'Download a listed version\\'s SBOM',\n    description: 'The SPDX JSON SBOM of a listed, non-yanked version\\'s public image, read from its signed '\n      + 'attestation. Anonymous; publicly cacheable.',\n    tags: publicTags,\n    security: [],\n    responses: {\n      200: { description: 'SPDX JSON document (application/spdx+json, served as an attachment)' },\n      404: { description: 'Not a listed version (unknown, yanked or paused)' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — no SBOM attestation verified' },\n      503: { description: 'Too many SBOM verifications in progress; retry after `Retry-After` seconds' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins',\n    summary: 'List plugins',\n    description: 'List plugins with pagination, filtering, and sorting.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Paginated list of plugins' }, 401: { description: 'Unauthorized' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/find',\n    summary: 'Find a single plugin',\n    description: 'Find a single plugin matching the query filters. For a plugin that runs on its own image, '\n      + 'the image\\'s cosign signature is verified first; `imageDigest` in the response is the verified digest '\n      + 'pipelines pin CodeBuild to. `name` matches exactly. A yanked version resolves only when pinned exactly '\n      + '(by `id` or an exact `version`). The answer is `{ plugin, warnings }`: `warnings` lists '\n      + '`PLUGIN_DEPRECATED` / `PLUGIN_YANKED` notices ({ code, message }) for the resolved version.',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: '`{ plugin, warnings }`' },\n      404: { description: 'Not found' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — the plugin image has no signed digest, or its signature did not verify' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/lookup',\n    summary: 'Resolve a single plugin (synth)',\n    description: 'Same as `GET /plugins/find` with the filter in the body — the endpoint pipeline synth resolves '\n      + 'plugins through. Verifies the plugin image signature before returning it. Synth prints the answer\\'s '\n      + '`warnings` (deprecated / yanked-but-pinned versions).',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: '`{ plugin, warnings }`' },\n      400: { description: 'Missing or invalid filter' },\n      404: { description: 'Not found' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — the plugin image has no signed digest, or its signature did not verify' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/{id}/sbom',\n    summary: 'Download a plugin image SBOM',\n    description: 'The SPDX JSON SBOM of the plugin image, read from its signed in-toto attestation — so the '\n      + 'document returned is exactly what the platform generated and signed at build time.',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: 'SPDX JSON document (application/spdx+json, served as an attachment)' },\n      404: { description: 'Plugin not found, or the plugin has no image' },\n      409: { description: 'IMAGE_VERIFICATION_FAILED — no SBOM attestation verified against the plugin-signing key' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/{id}',\n    summary: 'Get plugin by ID',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin details' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins',\n    summary: 'Upload a plugin',\n    description: 'Upload a plugin ZIP (multipart part `plugin`). Builds, signs and scans the image, then saves the '\n      + 'version. Optional parts: `visibility`, and `metadata` — a JSON object of catalog edits (summary, '\n      + 'description, displayName, category, keywords, license, homepageUrl, sourceUrl, documentationUrl, icon, '\n      + 'changelog, readme; `null` clears a field). When `metadata` is absent every value detected from the '\n      + 'package is accepted. Execution-contract keys in `metadata` are refused with 400.',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/inspect',\n    summary: 'Inspect a plugin zip (dry run)',\n    description: 'Parses a plugin ZIP (multipart part `plugin`) without building or storing anything and returns '\n      + 'every descriptive catalog field detected from the package: `{ plugin, fields: [{ field, value, source, '\n      + 'error }] }`. `source` is spec | readme | dockerfile | derived (or null when nothing was found); a value '\n      + 'that fails validation comes back blank with its `error`. Same zip bounds as upload; rate limited; '\n      + 'requires plugins:write.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Detected catalog fields' }, 400: { description: 'Invalid zip or spec' }, 429: { description: 'Rate limited' } },\n  });\n\n  registry.registerPath({\n    method: 'put',\n    path: '/plugins/{id}',\n    summary: 'Update a plugin',\n    description: 'Edit a version\\'s descriptive catalog fields (summary, description, displayName, category, '\n      + 'keywords, license, links, icon, changelog, readme) and its operational flags (isActive, isDefault, '\n      + 'visibility, lifecycle, criticality, labels, links, owner). Execution-contract keys (commands, env, '\n      + 'secrets, computeType, …) are refused with 400: they change only with a new version. A version that is '\n      + 'frozen by a publish request or listed has its catalog details frozen (409).',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: 'Plugin updated' },\n      400: { description: 'Validation error, or an execution-contract key' },\n      404: { description: 'Not found' },\n      409: { description: 'PLUGIN_VERSION_FROZEN — catalog details are frozen with the version' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'delete',\n    path: '/plugins/{id}',\n    summary: 'Delete a plugin version',\n    description: 'Soft-delete a version. A version used by the org\\'s pipelines or published to a listing is refused '\n      + 'unless `?force=true`, which requires a step-up token (`X-Step-Up-Token`). A version referenced by a pending '\n      + 'publish request is never deletable. Deleting the default promotes the next default; the version\\'s '\n      + '`plugins` quota slot is refunded while its quota period is current.',\n    tags,\n    security: auth,\n    responses: {\n      200: { description: 'Plugin deleted (`promotedDefault` when a new default was chosen)' },\n      401: { description: 'STEP_UP_REQUIRED — force delete without a step-up token' },\n      404: { description: 'Not found' },\n      409: { description: 'PLUGIN_VERSION_IN_USE / PLUGIN_VERSION_FROZEN' },\n    },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/{id}/deprecate',\n    summary: 'Deprecate a plugin version',\n    description: 'Body `{ deprecated?: boolean (default true), message?: string }`. A deprecated version keeps '\n      + 'resolving with a warning, and is no longer offered by AI plugin selection.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Updated version' }, 404: { description: 'Not found' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/{id}/yank',\n    summary: 'Yank a plugin version',\n    description: 'Body `{ reason }`. A yanked version stops resolving for ranges, `latest` and the default; an '\n      + 'exact pin still resolves with a warning. Yanking the default promotes the next one. A version published '\n      + 'to the ecosystem is yanked through a publish request instead (409).',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Yanked version (`promotedDefault` when a new default was chosen)' }, 404: { description: 'Not found' }, 409: { description: 'PLUGIN_VERSION_FROZEN' } },\n  });\n\n  registry.registerPath({\n    method: 'get',\n    path: '/plugins/providers',\n    summary: 'List AI providers',\n    description: 'List AI providers configured for plugin generation.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'List of available AI providers with models' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/generate',\n    summary: 'Generate plugin via AI',\n    description: 'Generate a plugin configuration and Dockerfile from a natural language prompt.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Generated plugin configuration and Dockerfile' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/generate/stream',\n    summary: 'Stream plugin generation via AI',\n    description: 'Generate plugin configuration from a natural language prompt. Streams partial results as SSE events.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'SSE event stream of partial plugin objects' }, 400: { description: 'Validation error' } },\n  });\n\n  registry.registerPath({\n    method: 'post',\n    path: '/plugins/deploy-generated',\n    summary: 'Deploy AI-generated plugin',\n    description: 'Build Docker image from AI-generated Dockerfile and save plugin to database. Requires admin.',\n    tags,\n    security: auth,\n    responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 403: { description: 'Admin required' }, 429: { description: 'Quota exceeded' } },\n  });\n}\n"]}

package/lib/openapi/schema-registry.js

@@ -3,7 +3,7 @@
 import { z } from 'zod';
 import { registry } from './registry.js';
 import { AIGenerateBodySchema, PluginDeployGeneratedSchema, } from '../validation/ai-schemas.js';
-import { VisibilitySchema, PaginationSchema, BaseFilterSchema, } from '../validation/common-schemas.js';
+import { VisibilitySchema, BaseFilterSchema, } from '../validation/common-schemas.js';
 import { MessageFilterSchema, MessageCreateSchema, MessageReplySchema, } from '../validation/message-schemas.js';
 import { PipelineFilterSchema, PipelineCreateSchema, PipelineUpdateSchema, } from '../validation/pipeline-schemas.js';
 import { PluginFilterSchema, PluginCreateSchema, PluginUpdateSchema, PluginUploadBodySchema, } from '../validation/plugin-schemas.js';
@@ -37,9 +37,6 @@ export function registerSchemas() {
         description: 'Sharing rung: "private" (author only), "org" (everyone in the owning organization), or "public" (the org, its teams, and — from the system org — every org)',
         example: 'private',
     }));
-    registry.register('PaginationParams', PaginationSchema.openapi({
-        description: 'Standard pagination and sorting parameters',
-    }));
     registry.register('BaseFilter', BaseFilterSchema.openapi({
         description: 'Common filter fields shared by all entity queries',
     }));
@@ -88,4 +85,4 @@ export function registerSchemas() {
     registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));
     registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-registry.js","sourceRoot":"","sources":["../../src/openapi/schema-registry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\n\nimport { registry } from './registry.js';\nimport {\n  AIGenerateBodySchema,\n  PluginDeployGeneratedSchema,\n} from '../validation/ai-schemas.js';\nimport {\n  VisibilitySchema,\n  PaginationSchema,\n  BaseFilterSchema,\n} from '../validation/common-schemas.js';\nimport {\n  MessageFilterSchema,\n  MessageCreateSchema,\n  MessageReplySchema,\n} from '../validation/message-schemas.js';\nimport {\n  PipelineFilterSchema,\n  PipelineCreateSchema,\n  PipelineUpdateSchema,\n} from '../validation/pipeline-schemas.js';\nimport {\n  PluginFilterSchema,\n  PluginCreateSchema,\n  PluginUpdateSchema,\n  PluginUploadBodySchema,\n} from '../validation/plugin-schemas.js';\n\n// Response schemas (exported for type usage)\nexport const SuccessResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.unknown().optional(),\n  message: z.string().optional(),\n});\n\nexport const ErrorResponseSchema = z.object({\n  success: z.literal(false),\n  statusCode: z.number(),\n  message: z.string(),\n  code: z.string().optional(),\n  details: z.unknown().optional(),\n});\n\nexport const PaginatedResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.array(z.unknown()),\n  count: z.number(),\n  limit: z.number(),\n  offset: z.number(),\n  total: z.number().optional(),\n  message: z.string().optional(),\n});\n\nexport function registerSchemas(): void {\n  // Common schemas\n  registry.register('Visibility', VisibilitySchema.openapi({\n    description: 'Sharing rung: \"private\" (author only), \"org\" (everyone in the owning organization), or \"public\" (the org, its teams, and — from the system org — every org)',\n    example: 'private',\n  }));\n\n  registry.register('PaginationParams', PaginationSchema.openapi({\n    description: 'Standard pagination and sorting parameters',\n  }));\n\n  registry.register('BaseFilter', BaseFilterSchema.openapi({\n    description: 'Common filter fields shared by all entity queries',\n  }));\n\n  // Pipeline schemas\n  registry.register('PipelineFilter', PipelineFilterSchema.openapi({\n    description: 'Query filters for listing pipelines',\n  }));\n\n  registry.register('PipelineCreate', PipelineCreateSchema.openapi({\n    description: 'Request body for creating a new pipeline',\n  }));\n\n  registry.register('PipelineUpdate', PipelineUpdateSchema.openapi({\n    description: 'Request body for updating an existing pipeline',\n  }));\n\n  // Plugin schemas\n  registry.register('PluginFilter', PluginFilterSchema.openapi({\n    description: 'Query filters for listing plugins',\n  }));\n\n  registry.register('PluginCreate', PluginCreateSchema.openapi({\n    description: 'Request body for creating a new plugin',\n  }));\n\n  registry.register('PluginUpdate', PluginUpdateSchema.openapi({\n    description: 'Request body for updating an existing plugin',\n  }));\n\n  registry.register('PluginUploadBody', PluginUploadBodySchema.openapi({\n    description: 'Metadata for plugin ZIP upload (multipart form-data)',\n  }));\n\n  // Message schemas\n  registry.register('MessageFilter', MessageFilterSchema.openapi({\n    description: 'Query filters for listing messages',\n  }));\n\n  registry.register('MessageCreate', MessageCreateSchema.openapi({\n    description: 'Request body for creating a new message or announcement',\n  }));\n\n  registry.register('MessageReply', MessageReplySchema.openapi({\n    description: 'Request body for replying to a message thread',\n  }));\n\n  // AI schemas\n  registry.register('AIGenerateBody', AIGenerateBodySchema.openapi({\n    description: 'Request body for AI-powered generation (pipeline or plugin)',\n  }));\n\n  registry.register('PluginDeployGenerated', PluginDeployGeneratedSchema.openapi({\n    description: 'Request body for deploying an AI-generated plugin',\n  }));\n\n  // Response schemas\n  registry.register('SuccessResponse', SuccessResponseSchema.openapi('SuccessResponse'));\n  registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));\n  registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-registry.js","sourceRoot":"","sources":["../../src/openapi/schema-registry.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { z } from 'zod';\n\nimport { registry } from './registry.js';\nimport {\n  AIGenerateBodySchema,\n  PluginDeployGeneratedSchema,\n} from '../validation/ai-schemas.js';\nimport {\n  VisibilitySchema,\n  BaseFilterSchema,\n} from '../validation/common-schemas.js';\nimport {\n  MessageFilterSchema,\n  MessageCreateSchema,\n  MessageReplySchema,\n} from '../validation/message-schemas.js';\nimport {\n  PipelineFilterSchema,\n  PipelineCreateSchema,\n  PipelineUpdateSchema,\n} from '../validation/pipeline-schemas.js';\nimport {\n  PluginFilterSchema,\n  PluginCreateSchema,\n  PluginUpdateSchema,\n  PluginUploadBodySchema,\n} from '../validation/plugin-schemas.js';\n\n// Response schemas (exported for type usage)\nexport const SuccessResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.unknown().optional(),\n  message: z.string().optional(),\n});\n\nexport const ErrorResponseSchema = z.object({\n  success: z.literal(false),\n  statusCode: z.number(),\n  message: z.string(),\n  code: z.string().optional(),\n  details: z.unknown().optional(),\n});\n\nexport const PaginatedResponseSchema = z.object({\n  success: z.literal(true),\n  statusCode: z.number(),\n  data: z.array(z.unknown()),\n  count: z.number(),\n  limit: z.number(),\n  offset: z.number(),\n  total: z.number().optional(),\n  message: z.string().optional(),\n});\n\nexport function registerSchemas(): void {\n  // Common schemas\n  registry.register('Visibility', VisibilitySchema.openapi({\n    description: 'Sharing rung: \"private\" (author only), \"org\" (everyone in the owning organization), or \"public\" (the org, its teams, and — from the system org — every org)',\n    example: 'private',\n  }));\n\n  registry.register('BaseFilter', BaseFilterSchema.openapi({\n    description: 'Common filter fields shared by all entity queries',\n  }));\n\n  // Pipeline schemas\n  registry.register('PipelineFilter', PipelineFilterSchema.openapi({\n    description: 'Query filters for listing pipelines',\n  }));\n\n  registry.register('PipelineCreate', PipelineCreateSchema.openapi({\n    description: 'Request body for creating a new pipeline',\n  }));\n\n  registry.register('PipelineUpdate', PipelineUpdateSchema.openapi({\n    description: 'Request body for updating an existing pipeline',\n  }));\n\n  // Plugin schemas\n  registry.register('PluginFilter', PluginFilterSchema.openapi({\n    description: 'Query filters for listing plugins',\n  }));\n\n  registry.register('PluginCreate', PluginCreateSchema.openapi({\n    description: 'Request body for creating a new plugin',\n  }));\n\n  registry.register('PluginUpdate', PluginUpdateSchema.openapi({\n    description: 'Request body for updating an existing plugin',\n  }));\n\n  registry.register('PluginUploadBody', PluginUploadBodySchema.openapi({\n    description: 'Metadata for plugin ZIP upload (multipart form-data)',\n  }));\n\n  // Message schemas\n  registry.register('MessageFilter', MessageFilterSchema.openapi({\n    description: 'Query filters for listing messages',\n  }));\n\n  registry.register('MessageCreate', MessageCreateSchema.openapi({\n    description: 'Request body for creating a new message or announcement',\n  }));\n\n  registry.register('MessageReply', MessageReplySchema.openapi({\n    description: 'Request body for replying to a message thread',\n  }));\n\n  // AI schemas\n  registry.register('AIGenerateBody', AIGenerateBodySchema.openapi({\n    description: 'Request body for AI-powered generation (pipeline or plugin)',\n  }));\n\n  registry.register('PluginDeployGenerated', PluginDeployGeneratedSchema.openapi({\n    description: 'Request body for deploying an AI-generated plugin',\n  }));\n\n  // Response schemas\n  registry.register('SuccessResponse', SuccessResponseSchema.openapi('SuccessResponse'));\n  registry.register('ErrorResponse', ErrorResponseSchema.openapi('ErrorResponse'));\n  registry.register('PaginatedResponse', PaginatedResponseSchema.openapi('PaginatedResponse'));\n}\n"]}

package/lib/routes/index.d.ts

@@ -1 +1 @@
-export * from './health.js';
+export { createHealthCheck, createReadinessCheck, createHealthRouter, } from './health.js';

package/lib/routes/index.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-export * from './health.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcm91dGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9oZWFsdGguanMnO1xuIl19
+export { createHealthCheck, createReadinessCheck, createHealthRouter, } from './health.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcm91dGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsT0FBTyxFQUNMLGlCQUFpQixFQUNqQixvQkFBb0IsRUFDcEIsa0JBQWtCLEdBQ25CLE1BQU0sYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCB7XG4gIGNyZWF0ZUhlYWx0aENoZWNrLFxuICBjcmVhdGVSZWFkaW5lc3NDaGVjayxcbiAgY3JlYXRlSGVhbHRoUm91dGVyLFxufSBmcm9tICcuL2hlYWx0aC5qcyc7XG4iXX0=

package/lib/services/api-key-exchange.js

@@ -31,12 +31,15 @@
  * pod's exchanges would otherwise share one bucket) and names the caller in
  * platform's audit trail.
  */
-import { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';
+import { getServiceAuthHeader } from '../middleware/service-tokens.js';
+import { SYSTEM_ORG_ID } from '../middleware/system-org.js';
 import { InternalHttpClient } from '../services/http-client.js';
 import { hashApiKey } from '../utils/api-key.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 import { errorMessage } from '../utils/response.js';
+import { envInt } from '../utils/env.js';
+import { serviceEndpoint } from '../utils/service-registry.js';
 const logger = createLogger('api-key-exchange');
 /** Most distinct keys held in the process-wide cache before the oldest are dropped. */
 const MAX_CACHED_KEYS = 1000;
@@ -81,9 +84,8 @@ export function setApiKeyExchangeServiceName(name) {
 /** Platform's in-cluster address — the same env pair every other caller uses. */
 function platformClient() {
     return new InternalHttpClient({
-        host: process.env.PLATFORM_SERVICE_HOST || 'platform',
-        port: parseInt(process.env.PLATFORM_SERVICE_PORT || '3000', 10),
-        timeout: parseInt(process.env.API_KEY_EXCHANGE_TIMEOUT_MS || '3000', 10),
+        ...serviceEndpoint('platform'),
+        timeout: envInt('API_KEY_EXCHANGE_TIMEOUT_MS', 3000, { min: 1 }),
     });
 }
 /** The epoch ms at which a token with `ttlSeconds` of life should be refreshed early. */
@@ -217,4 +219,4 @@ export function resetApiKeyExchangeCache() {
     rejectionCache.clear();
     inFlight.clear();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-key-exchange.js","sourceRoot":"","sources":["../../src/services/api-key-exchange.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Trade an opaque access key for a short-lived JWT, once, and cache it.\n *\n * Only platform, billing and quota have MongoDB, so the stateless services\n * cannot look up a key hash — and asking platform to validate EVERY request\n * would put it on the hot path of the whole fleet. Instead this module does the\n * exchange once per key (`POST /auth/token/exchange`) and caches the returned\n * JWT in-process until it expires, so `requireAuth` only ever verifies a JWT.\n *\n * Properties that matter:\n *\n * - **Revocation latency is bounded by the token TTL** (5 minutes). A revoked\n *   key can no longer be exchanged, and the cached token it already produced\n *   dies on its own.\n * - **Early, jittered refresh.** The cached token is re-exchanged in the\n *   background at ~75% of its life (±20% jitter) so no request ever blocks on\n *   the exchange, and a fleet of pods holding the same key doesn't stampede\n *   platform at the same instant.\n * - **One in-flight exchange per key.** Concurrent requests share a promise.\n * - **Short negative cache.** A key platform rejected is remembered for 30s, so\n *   a misconfigured client (or a scanner) can't turn every request into a\n *   platform round-trip.\n * - **Platform down is a 503, never a 200.** The caller maps\n *   {@link ApiKeyExchangeUnavailableError} to \"try again\", with a metric — it is\n *   deliberately NOT fail-open: an unverifiable credential is not an identity.\n *\n * The exchange request itself carries this service's own signed service token,\n * which is what exempts it from platform's IP-keyed `/auth` rate limiter (every\n * pod's exchanges would otherwise share one bucket) and names the caller in\n * platform's audit trail.\n */\n\nimport { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport { hashApiKey } from '../utils/api-key.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('api-key-exchange');\n\n/** Most distinct keys held in the process-wide cache before the oldest are dropped. */\nconst MAX_CACHED_KEYS = 1000;\n\n/** How long a platform REJECTION is remembered (ms). */\nconst NEGATIVE_TTL_MS = 30_000;\n\n/** Fraction of a token's life after which a background re-exchange is started. */\nconst REFRESH_AT_FRACTION = 0.75;\n\n/** ± jitter applied to the refresh point, as a fraction of the token's life.\n *  Wide enough to de-synchronize a fleet, narrow enough to leave a clear tail of\n *  still-valid token after the latest possible refresh. */\nconst REFRESH_JITTER_FRACTION = 0.1;\n\n/** The key was presented to platform and refused (unknown, revoked, expired). */\nexport class ApiKeyRejectedError extends Error {\n  constructor(message = 'Access key is invalid, revoked or expired') {\n    super(message);\n    this.name = 'ApiKeyRejectedError';\n  }\n}\n\n/** Platform could not be reached (or answered 5xx) — the key's validity is unknown. */\nexport class ApiKeyExchangeUnavailableError extends Error {\n  constructor(message = 'Access-key verification is temporarily unavailable') {\n    super(message);\n    this.name = 'ApiKeyExchangeUnavailableError';\n  }\n}\n\ninterface CacheEntry {\n  /** The exchanged JWT. */\n  token: string;\n  /** Epoch ms at which the JWT stops being usable. */\n  expiresAt: number;\n  /** Epoch ms after which a background re-exchange should be started. */\n  refreshAt: number;\n}\n\n/** Cache of successful exchanges, keyed by `sha256(key)` — never by the key itself. */\nconst tokenCache = new Map<string, CacheEntry>();\n/** Cache of rejections, keyed the same way; value is the epoch ms it expires. */\nconst rejectionCache = new Map<string, number>();\n/** In-flight exchanges, so concurrent requests for one key share a round-trip. */\nconst inFlight = new Map<string, Promise<CacheEntry>>();\n\n/** The service name minted into the exchange call's own service token. */\nlet serviceName = process.env.SERVICE_NAME || 'unknown';\n\n/**\n * Name this process in the exchange call's service token. Called from\n * `wireServiceSecurity` at boot (and by the plugin service, which wires its\n * boot security by hand).\n */\nexport function setApiKeyExchangeServiceName(name: string): void {\n  serviceName = name;\n}\n\n/** Platform's in-cluster address — the same env pair every other caller uses. */\nfunction platformClient(): InternalHttpClient {\n  return new InternalHttpClient({\n    host: process.env.PLATFORM_SERVICE_HOST || 'platform',\n    port: parseInt(process.env.PLATFORM_SERVICE_PORT || '3000', 10),\n    timeout: parseInt(process.env.API_KEY_EXCHANGE_TIMEOUT_MS || '3000', 10),\n  });\n}\n\n/** The epoch ms at which a token with `ttlSeconds` of life should be refreshed early. */\nfunction jitteredRefreshAt(issuedAt: number, ttlSeconds: number): number {\n  const lifeMs = ttlSeconds * 1000;\n  const jitter = (Math.random() * 2 - 1) * REFRESH_JITTER_FRACTION;\n  // Clamp into (0, 1) so the refresh point is always before expiry and never in\n  // the past, whatever TTL platform returns.\n  const fraction = Math.min(0.95, Math.max(0.1, REFRESH_AT_FRACTION + jitter));\n  return issuedAt + lifeMs * fraction;\n}\n\n/** Drop the oldest entries once the cache is over its cap (keys are long-lived, tokens are not). */\nfunction evictIfFull(): void {\n  if (tokenCache.size <= MAX_CACHED_KEYS) return;\n  const now = Date.now();\n  for (const [hash, entry] of tokenCache) {\n    if (entry.expiresAt <= now) tokenCache.delete(hash);\n  }\n  // Map preserves insertion order — drop from the front until back under the cap.\n  while (tokenCache.size > MAX_CACHED_KEYS) {\n    const oldest = tokenCache.keys().next();\n    if (oldest.done) break;\n    tokenCache.delete(oldest.value);\n  }\n}\n\ninterface ExchangeResponse {\n  success?: boolean;\n  data?: { accessToken?: string; expiresIn?: number };\n}\n\n/** One real round-trip to platform. Throws the two typed errors above. */\nasync function performExchange(key: string, hash: string): Promise<CacheEntry> {\n  const client = platformClient();\n  let status: number;\n  let body: ExchangeResponse;\n  try {\n    const res = await client.post<ExchangeResponse>('/auth/token/exchange', { key }, {\n      headers: {\n        Authorization: getServiceAuthHeader({ serviceName, role: 'member', orgId: SYSTEM_ORG_ID }),\n      },\n      // The exchange is a pure read of the key record plus a token mint — safe to\n      // retry, and a lost retry only costs one extra mint.\n      idempotent: true,\n    });\n    status = res.statusCode;\n    body = res.body;\n  } catch (err) {\n    emitCounter('api_key_exchange_total', { result: 'unavailable' });\n    emitCounter('api_key_exchange_failures_total', { reason: 'unavailable' });\n    logger.warn('Access-key exchange failed to reach platform', {\n      error: errorMessage(err),\n    });\n    throw new ApiKeyExchangeUnavailableError();\n  }\n\n  if (status === 401 || status === 403 || status === 400 || status === 404) {\n    rejectionCache.set(hash, Date.now() + NEGATIVE_TTL_MS);\n    emitCounter('api_key_exchange_total', { result: 'rejected' });\n    emitCounter('api_key_exchange_failures_total', { reason: 'rejected' });\n    throw new ApiKeyRejectedError();\n  }\n\n  const accessToken = body?.data?.accessToken;\n  if (status >= 400 || typeof accessToken !== 'string' || accessToken.length === 0) {\n    // 429 and 5xx land here: platform is up but can't answer right now, which is\n    // \"unknown\", not \"invalid\" — never cache it as a rejection.\n    emitCounter('api_key_exchange_total', { result: 'unavailable' });\n    emitCounter('api_key_exchange_failures_total', { reason: status === 429 ? 'throttled' : 'server_error' });\n    throw new ApiKeyExchangeUnavailableError();\n  }\n\n  const ttlSeconds = typeof body?.data?.expiresIn === 'number' && body.data.expiresIn > 0\n    ? body.data.expiresIn\n    : 60;\n  const now = Date.now();\n  const entry: CacheEntry = {\n    token: accessToken,\n    expiresAt: now + ttlSeconds * 1000,\n    refreshAt: jitteredRefreshAt(now, ttlSeconds),\n  };\n  tokenCache.set(hash, entry);\n  rejectionCache.delete(hash);\n  evictIfFull();\n  emitCounter('api_key_exchange_total', { result: 'success' });\n  return entry;\n}\n\n/** Exchange, sharing a single in-flight round-trip per key. */\nfunction exchangeOnce(key: string, hash: string): Promise<CacheEntry> {\n  const pending = inFlight.get(hash);\n  if (pending) return pending;\n  const promise = performExchange(key, hash).finally(() => inFlight.delete(hash));\n  inFlight.set(hash, promise);\n  return promise;\n}\n\n/**\n * The JWT for `key`, from cache when possible. Throws {@link ApiKeyRejectedError}\n * when platform refused the key and {@link ApiKeyExchangeUnavailableError} when\n * it could not be asked.\n */\nexport async function exchangeApiKey(key: string): Promise<string> {\n  const hash = hashApiKey(key);\n  const now = Date.now();\n\n  const rejectedUntil = rejectionCache.get(hash);\n  if (rejectedUntil !== undefined) {\n    if (rejectedUntil > now) {\n      emitCounter('api_key_exchange_cache_total', { result: 'rejected' });\n      throw new ApiKeyRejectedError();\n    }\n    rejectionCache.delete(hash);\n  }\n\n  const cached = tokenCache.get(hash);\n  if (cached && cached.expiresAt > now) {\n    if (cached.refreshAt <= now && !inFlight.has(hash)) {\n      // Early refresh: warm the cache WITHOUT making this request wait. A failed\n      // background refresh is not this request's problem — the cached token is\n      // still valid, and the next request past expiry exchanges inline.\n      emitCounter('api_key_exchange_cache_total', { result: 'refresh' });\n      void exchangeOnce(key, hash).catch(() => { /* logged + counted in performExchange */ });\n    } else {\n      emitCounter('api_key_exchange_cache_total', { result: 'hit' });\n    }\n    return cached.token;\n  }\n\n  emitCounter('api_key_exchange_cache_total', { result: 'miss' });\n  return (await exchangeOnce(key, hash)).token;\n}\n\n/**\n * Drop every cached exchange. For tests and for a process that wants to force\n * re-validation; production relies on the TTLs above.\n */\nexport function resetApiKeyExchangeCache(): void {\n  tokenCache.clear();\n  rejectionCache.clear();\n  inFlight.clear();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-key-exchange.js","sourceRoot":"","sources":["../../src/services/api-key-exchange.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Trade an opaque access key for a short-lived JWT, once, and cache it.\n *\n * Only platform, billing and quota have MongoDB, so the stateless services\n * cannot look up a key hash — and asking platform to validate EVERY request\n * would put it on the hot path of the whole fleet. Instead this module does the\n * exchange once per key (`POST /auth/token/exchange`) and caches the returned\n * JWT in-process until it expires, so `requireAuth` only ever verifies a JWT.\n *\n * Properties that matter:\n *\n * - **Revocation latency is bounded by the token TTL** (5 minutes). A revoked\n *   key can no longer be exchanged, and the cached token it already produced\n *   dies on its own.\n * - **Early, jittered refresh.** The cached token is re-exchanged in the\n *   background at ~75% of its life (±20% jitter) so no request ever blocks on\n *   the exchange, and a fleet of pods holding the same key doesn't stampede\n *   platform at the same instant.\n * - **One in-flight exchange per key.** Concurrent requests share a promise.\n * - **Short negative cache.** A key platform rejected is remembered for 30s, so\n *   a misconfigured client (or a scanner) can't turn every request into a\n *   platform round-trip.\n * - **Platform down is a 503, never a 200.** The caller maps\n *   {@link ApiKeyExchangeUnavailableError} to \"try again\", with a metric — it is\n *   deliberately NOT fail-open: an unverifiable credential is not an identity.\n *\n * The exchange request itself carries this service's own signed service token,\n * which is what exempts it from platform's IP-keyed `/auth` rate limiter (every\n * pod's exchanges would otherwise share one bucket) and names the caller in\n * platform's audit trail.\n */\n\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport { SYSTEM_ORG_ID } from '../middleware/system-org.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport { hashApiKey } from '../utils/api-key.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\nimport { envInt } from '../utils/env.js';\nimport { serviceEndpoint } from '../utils/service-registry.js';\n\nconst logger = createLogger('api-key-exchange');\n\n/** Most distinct keys held in the process-wide cache before the oldest are dropped. */\nconst MAX_CACHED_KEYS = 1000;\n\n/** How long a platform REJECTION is remembered (ms). */\nconst NEGATIVE_TTL_MS = 30_000;\n\n/** Fraction of a token's life after which a background re-exchange is started. */\nconst REFRESH_AT_FRACTION = 0.75;\n\n/** ± jitter applied to the refresh point, as a fraction of the token's life.\n *  Wide enough to de-synchronize a fleet, narrow enough to leave a clear tail of\n *  still-valid token after the latest possible refresh. */\nconst REFRESH_JITTER_FRACTION = 0.1;\n\n/** The key was presented to platform and refused (unknown, revoked, expired). */\nexport class ApiKeyRejectedError extends Error {\n  constructor(message = 'Access key is invalid, revoked or expired') {\n    super(message);\n    this.name = 'ApiKeyRejectedError';\n  }\n}\n\n/** Platform could not be reached (or answered 5xx) — the key's validity is unknown. */\nexport class ApiKeyExchangeUnavailableError extends Error {\n  constructor(message = 'Access-key verification is temporarily unavailable') {\n    super(message);\n    this.name = 'ApiKeyExchangeUnavailableError';\n  }\n}\n\ninterface CacheEntry {\n  /** The exchanged JWT. */\n  token: string;\n  /** Epoch ms at which the JWT stops being usable. */\n  expiresAt: number;\n  /** Epoch ms after which a background re-exchange should be started. */\n  refreshAt: number;\n}\n\n/** Cache of successful exchanges, keyed by `sha256(key)` — never by the key itself. */\nconst tokenCache = new Map<string, CacheEntry>();\n/** Cache of rejections, keyed the same way; value is the epoch ms it expires. */\nconst rejectionCache = new Map<string, number>();\n/** In-flight exchanges, so concurrent requests for one key share a round-trip. */\nconst inFlight = new Map<string, Promise<CacheEntry>>();\n\n/** The service name minted into the exchange call's own service token. */\nlet serviceName = process.env.SERVICE_NAME || 'unknown';\n\n/**\n * Name this process in the exchange call's service token. Called from\n * `wireServiceSecurity` at boot (and by the plugin service, which wires its\n * boot security by hand).\n */\nexport function setApiKeyExchangeServiceName(name: string): void {\n  serviceName = name;\n}\n\n/** Platform's in-cluster address — the same env pair every other caller uses. */\nfunction platformClient(): InternalHttpClient {\n  return new InternalHttpClient({\n    ...serviceEndpoint('platform'),\n    timeout: envInt('API_KEY_EXCHANGE_TIMEOUT_MS', 3000, { min: 1 }),\n  });\n}\n\n/** The epoch ms at which a token with `ttlSeconds` of life should be refreshed early. */\nfunction jitteredRefreshAt(issuedAt: number, ttlSeconds: number): number {\n  const lifeMs = ttlSeconds * 1000;\n  const jitter = (Math.random() * 2 - 1) * REFRESH_JITTER_FRACTION;\n  // Clamp into (0, 1) so the refresh point is always before expiry and never in\n  // the past, whatever TTL platform returns.\n  const fraction = Math.min(0.95, Math.max(0.1, REFRESH_AT_FRACTION + jitter));\n  return issuedAt + lifeMs * fraction;\n}\n\n/** Drop the oldest entries once the cache is over its cap (keys are long-lived, tokens are not). */\nfunction evictIfFull(): void {\n  if (tokenCache.size <= MAX_CACHED_KEYS) return;\n  const now = Date.now();\n  for (const [hash, entry] of tokenCache) {\n    if (entry.expiresAt <= now) tokenCache.delete(hash);\n  }\n  // Map preserves insertion order — drop from the front until back under the cap.\n  while (tokenCache.size > MAX_CACHED_KEYS) {\n    const oldest = tokenCache.keys().next();\n    if (oldest.done) break;\n    tokenCache.delete(oldest.value);\n  }\n}\n\ninterface ExchangeResponse {\n  success?: boolean;\n  data?: { accessToken?: string; expiresIn?: number };\n}\n\n/** One real round-trip to platform. Throws the two typed errors above. */\nasync function performExchange(key: string, hash: string): Promise<CacheEntry> {\n  const client = platformClient();\n  let status: number;\n  let body: ExchangeResponse;\n  try {\n    const res = await client.post<ExchangeResponse>('/auth/token/exchange', { key }, {\n      headers: {\n        Authorization: getServiceAuthHeader({ serviceName, role: 'member', orgId: SYSTEM_ORG_ID }),\n      },\n      // The exchange is a pure read of the key record plus a token mint — safe to\n      // retry, and a lost retry only costs one extra mint.\n      idempotent: true,\n    });\n    status = res.statusCode;\n    body = res.body;\n  } catch (err) {\n    emitCounter('api_key_exchange_total', { result: 'unavailable' });\n    emitCounter('api_key_exchange_failures_total', { reason: 'unavailable' });\n    logger.warn('Access-key exchange failed to reach platform', {\n      error: errorMessage(err),\n    });\n    throw new ApiKeyExchangeUnavailableError();\n  }\n\n  if (status === 401 || status === 403 || status === 400 || status === 404) {\n    rejectionCache.set(hash, Date.now() + NEGATIVE_TTL_MS);\n    emitCounter('api_key_exchange_total', { result: 'rejected' });\n    emitCounter('api_key_exchange_failures_total', { reason: 'rejected' });\n    throw new ApiKeyRejectedError();\n  }\n\n  const accessToken = body?.data?.accessToken;\n  if (status >= 400 || typeof accessToken !== 'string' || accessToken.length === 0) {\n    // 429 and 5xx land here: platform is up but can't answer right now, which is\n    // \"unknown\", not \"invalid\" — never cache it as a rejection.\n    emitCounter('api_key_exchange_total', { result: 'unavailable' });\n    emitCounter('api_key_exchange_failures_total', { reason: status === 429 ? 'throttled' : 'server_error' });\n    throw new ApiKeyExchangeUnavailableError();\n  }\n\n  const ttlSeconds = typeof body?.data?.expiresIn === 'number' && body.data.expiresIn > 0\n    ? body.data.expiresIn\n    : 60;\n  const now = Date.now();\n  const entry: CacheEntry = {\n    token: accessToken,\n    expiresAt: now + ttlSeconds * 1000,\n    refreshAt: jitteredRefreshAt(now, ttlSeconds),\n  };\n  tokenCache.set(hash, entry);\n  rejectionCache.delete(hash);\n  evictIfFull();\n  emitCounter('api_key_exchange_total', { result: 'success' });\n  return entry;\n}\n\n/** Exchange, sharing a single in-flight round-trip per key. */\nfunction exchangeOnce(key: string, hash: string): Promise<CacheEntry> {\n  const pending = inFlight.get(hash);\n  if (pending) return pending;\n  const promise = performExchange(key, hash).finally(() => inFlight.delete(hash));\n  inFlight.set(hash, promise);\n  return promise;\n}\n\n/**\n * The JWT for `key`, from cache when possible. Throws {@link ApiKeyRejectedError}\n * when platform refused the key and {@link ApiKeyExchangeUnavailableError} when\n * it could not be asked.\n */\nexport async function exchangeApiKey(key: string): Promise<string> {\n  const hash = hashApiKey(key);\n  const now = Date.now();\n\n  const rejectedUntil = rejectionCache.get(hash);\n  if (rejectedUntil !== undefined) {\n    if (rejectedUntil > now) {\n      emitCounter('api_key_exchange_cache_total', { result: 'rejected' });\n      throw new ApiKeyRejectedError();\n    }\n    rejectionCache.delete(hash);\n  }\n\n  const cached = tokenCache.get(hash);\n  if (cached && cached.expiresAt > now) {\n    if (cached.refreshAt <= now && !inFlight.has(hash)) {\n      // Early refresh: warm the cache WITHOUT making this request wait. A failed\n      // background refresh is not this request's problem — the cached token is\n      // still valid, and the next request past expiry exchanges inline.\n      emitCounter('api_key_exchange_cache_total', { result: 'refresh' });\n      void exchangeOnce(key, hash).catch(() => { /* logged + counted in performExchange */ });\n    } else {\n      emitCounter('api_key_exchange_cache_total', { result: 'hit' });\n    }\n    return cached.token;\n  }\n\n  emitCounter('api_key_exchange_cache_total', { result: 'miss' });\n  return (await exchangeOnce(key, hash)).token;\n}\n\n/**\n * Drop every cached exchange. For tests and for a process that wants to force\n * re-validation; production relies on the TTLs above.\n */\nexport function resetApiKeyExchangeCache(): void {\n  tokenCache.clear();\n  rejectionCache.clear();\n  inFlight.clear();\n}\n"]}