@pipeline-builder/api-core 3.1.0

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

@@ -0,0 +1,90 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPipelineRoutes = registerPipelineRoutes;
+const registry_1 = require("../registry");
+const tags = ['Pipelines'];
+const auth = [{ bearerAuth: [] }];
+function registerPipelineRoutes() {
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/pipelines',
+        summary: 'List pipelines',
+        description: 'List pipelines with pagination, filtering, and sorting.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Paginated list of pipelines' }, 401: { description: 'Unauthorized' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/pipelines/find',
+        summary: 'Find a single pipeline',
+        description: 'Find a single pipeline matching the query filters.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline found' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/pipelines/{id}',
+        summary: 'Get pipeline by ID',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline details' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/pipelines',
+        summary: 'Create a pipeline',
+        description: 'Create a new pipeline configuration. Checks pipeline quota.',
+        tags,
+        security: auth,
+        responses: { 201: { description: 'Pipeline created' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'put',
+        path: '/pipelines/{id}',
+        summary: 'Update a pipeline',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline updated' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'delete',
+        path: '/pipelines/{id}',
+        summary: 'Delete a pipeline',
+        description: 'Soft-delete a pipeline by setting isActive to false.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Pipeline deleted' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/pipelines/providers',
+        summary: 'List AI providers',
+        description: 'List AI providers configured for pipeline generation.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of available AI providers with models' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/pipelines/generate',
+        summary: 'Generate pipeline via AI',
+        description: 'Generate a BuilderProps configuration from a natural language prompt. Returns the complete result when done.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Generated pipeline configuration' }, 400: { description: 'Validation error' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/pipelines/generate/stream',
+        summary: 'Stream pipeline generation via AI',
+        description: 'Generate a BuilderProps configuration from a natural language prompt. Streams partial results as SSE events.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'SSE event stream of partial pipeline objects' }, 400: { description: 'Validation error' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/plugin-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerPluginRoutes(): void;

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

@@ -0,0 +1,99 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPluginRoutes = registerPluginRoutes;
+const registry_1 = require("../registry");
+const tags = ['Plugins'];
+const auth = [{ bearerAuth: [] }];
+function registerPluginRoutes() {
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/plugins',
+        summary: 'List plugins',
+        description: 'List plugins with pagination, filtering, and sorting.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Paginated list of plugins' }, 401: { description: 'Unauthorized' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/plugins/find',
+        summary: 'Find a single plugin',
+        description: 'Find a single plugin matching the query filters.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin found' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/plugins/{id}',
+        summary: 'Get plugin by ID',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin details' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/plugins',
+        summary: 'Upload a plugin',
+        description: 'Upload a plugin ZIP file with spec. Builds Docker image and saves to database.',
+        tags,
+        security: auth,
+        responses: { 202: { description: 'Plugin build queued' }, 400: { description: 'Validation error' }, 429: { description: 'Quota exceeded' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'put',
+        path: '/plugins/{id}',
+        summary: 'Update a plugin',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin updated' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'delete',
+        path: '/plugins/{id}',
+        summary: 'Delete a plugin',
+        description: 'Soft-delete a plugin by setting isActive to false.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Plugin deleted' }, 404: { description: 'Not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/plugins/providers',
+        summary: 'List AI providers',
+        description: 'List AI providers configured for plugin generation.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of available AI providers with models' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/plugins/generate',
+        summary: 'Generate plugin via AI',
+        description: 'Generate a plugin configuration and Dockerfile from a natural language prompt.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Generated plugin configuration and Dockerfile' }, 400: { description: 'Validation error' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/plugins/generate/stream',
+        summary: 'Stream plugin generation via AI',
+        description: 'Generate plugin configuration from a natural language prompt. Streams partial results as SSE events.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'SSE event stream of partial plugin objects' }, 400: { description: 'Validation error' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/plugins/deploy-generated',
+        summary: 'Deploy AI-generated plugin',
+        description: 'Build Docker image from AI-generated Dockerfile and save plugin to database. Requires admin.',
+        tags,
+        security: auth,
+        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';\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.',\n    tags,\n    security: auth,\n    responses: { 200: { description: 'Plugin found' }, 404: { description: 'Not found' } },\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"]}

package/lib/openapi/routes/quota-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerQuotaRoutes(): void;

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

@@ -0,0 +1,65 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerQuotaRoutes = registerQuotaRoutes;
+const registry_1 = require("../registry");
+const tags = ['Quotas'];
+const auth = [{ bearerAuth: [] }];
+function registerQuotaRoutes() {
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/quotas',
+        summary: 'Get own quotas',
+        description: 'Get quota usage and limits for the current organization (from JWT).',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Organization quota details' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/quotas/all',
+        summary: 'Get all org quotas',
+        description: 'Get quotas for all organizations. System admin only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'All organization quotas' }, 403: { description: 'Admin required' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/quotas/{orgId}',
+        summary: 'Get org quotas',
+        description: 'Get quota usage and limits for a specific organization.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Organization quota details' }, 404: { description: 'Organization not found' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'get',
+        path: '/quotas/{orgId}/{quotaType}',
+        summary: 'Get specific quota',
+        description: 'Get a specific quota type for an organization.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Quota type details' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'put',
+        path: '/quotas/{orgId}',
+        summary: 'Update org quotas',
+        description: 'Update quota limits for an organization. System admin only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Quotas updated' }, 403: { description: 'Admin required' } },
+    });
+    registry_1.registry.registerPath({
+        method: 'post',
+        path: '/quotas/{orgId}/reset',
+        summary: 'Reset quota usage',
+        description: 'Reset usage counters for an organization. Admin only.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Quota usage reset' }, 403: { description: 'Admin required' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/schema-registry.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const SuccessResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    statusCode: z.ZodNumber;
+    data: z.ZodOptional<z.ZodUnknown>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ErrorResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    statusCode: z.ZodNumber;
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const PaginatedResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    statusCode: z.ZodNumber;
+    data: z.ZodArray<z.ZodUnknown>;
+    count: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+    total: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function registerSchemas(): void;

package/lib/openapi/schema-registry.js

@@ -0,0 +1,95 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginatedResponseSchema = exports.ErrorResponseSchema = exports.SuccessResponseSchema = void 0;
+exports.registerSchemas = registerSchemas;
+const zod_1 = require("zod");
+const registry_1 = require("./registry");
+const ai_schemas_1 = require("../validation/ai-schemas");
+const common_schemas_1 = require("../validation/common-schemas");
+const message_schemas_1 = require("../validation/message-schemas");
+const pipeline_schemas_1 = require("../validation/pipeline-schemas");
+const plugin_schemas_1 = require("../validation/plugin-schemas");
+// Response schemas (exported for type usage)
+exports.SuccessResponseSchema = zod_1.z.object({
+    success: zod_1.z.literal(true),
+    statusCode: zod_1.z.number(),
+    data: zod_1.z.unknown().optional(),
+    message: zod_1.z.string().optional(),
+});
+exports.ErrorResponseSchema = zod_1.z.object({
+    success: zod_1.z.literal(false),
+    statusCode: zod_1.z.number(),
+    message: zod_1.z.string(),
+    code: zod_1.z.string().optional(),
+    details: zod_1.z.unknown().optional(),
+});
+exports.PaginatedResponseSchema = zod_1.z.object({
+    success: zod_1.z.literal(true),
+    statusCode: zod_1.z.number(),
+    data: zod_1.z.array(zod_1.z.unknown()),
+    count: zod_1.z.number(),
+    limit: zod_1.z.number(),
+    offset: zod_1.z.number(),
+    total: zod_1.z.number().optional(),
+    message: zod_1.z.string().optional(),
+});
+function registerSchemas() {
+    // Common schemas
+    registry_1.registry.register('AccessModifier', common_schemas_1.AccessModifierSchema.openapi({
+        description: 'Resource visibility: "public" (visible to all) or "private" (organization only)',
+        example: 'private',
+    }));
+    registry_1.registry.register('PaginationParams', common_schemas_1.PaginationSchema.openapi({
+        description: 'Standard pagination and sorting parameters',
+    }));
+    registry_1.registry.register('BaseFilter', common_schemas_1.BaseFilterSchema.openapi({
+        description: 'Common filter fields shared by all entity queries',
+    }));
+    // Pipeline schemas
+    registry_1.registry.register('PipelineFilter', pipeline_schemas_1.PipelineFilterSchema.openapi({
+        description: 'Query filters for listing pipelines',
+    }));
+    registry_1.registry.register('PipelineCreate', pipeline_schemas_1.PipelineCreateSchema.openapi({
+        description: 'Request body for creating a new pipeline',
+    }));
+    registry_1.registry.register('PipelineUpdate', pipeline_schemas_1.PipelineUpdateSchema.openapi({
+        description: 'Request body for updating an existing pipeline',
+    }));
+    // Plugin schemas
+    registry_1.registry.register('PluginFilter', plugin_schemas_1.PluginFilterSchema.openapi({
+        description: 'Query filters for listing plugins',
+    }));
+    registry_1.registry.register('PluginCreate', plugin_schemas_1.PluginCreateSchema.openapi({
+        description: 'Request body for creating a new plugin',
+    }));
+    registry_1.registry.register('PluginUpdate', plugin_schemas_1.PluginUpdateSchema.openapi({
+        description: 'Request body for updating an existing plugin',
+    }));
+    registry_1.registry.register('PluginUploadBody', plugin_schemas_1.PluginUploadBodySchema.openapi({
+        description: 'Metadata for plugin ZIP upload (multipart form-data)',
+    }));
+    // Message schemas
+    registry_1.registry.register('MessageFilter', message_schemas_1.MessageFilterSchema.openapi({
+        description: 'Query filters for listing messages',
+    }));
+    registry_1.registry.register('MessageCreate', message_schemas_1.MessageCreateSchema.openapi({
+        description: 'Request body for creating a new message or announcement',
+    }));
+    registry_1.registry.register('MessageReply', message_schemas_1.MessageReplySchema.openapi({
+        description: 'Request body for replying to a message thread',
+    }));
+    // AI schemas
+    registry_1.registry.register('AIGenerateBody', ai_schemas_1.AIGenerateBodySchema.openapi({
+        description: 'Request body for AI-powered generation (pipeline or plugin)',
+    }));
+    registry_1.registry.register('PluginDeployGenerated', ai_schemas_1.PluginDeployGeneratedSchema.openapi({
+        description: 'Request body for deploying an AI-generated plugin',
+    }));
+    // Response schemas
+    registry_1.registry.register('SuccessResponse', exports.SuccessResponseSchema.openapi('SuccessResponse'));
+    registry_1.registry.register('ErrorResponse', exports.ErrorResponseSchema.openapi('ErrorResponse'));
+    registry_1.registry.register('PaginatedResponse', exports.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';\nimport {\n  AIGenerateBodySchema,\n  PluginDeployGeneratedSchema,\n} from '../validation/ai-schemas';\nimport {\n  AccessModifierSchema,\n  PaginationSchema,\n  BaseFilterSchema,\n} from '../validation/common-schemas';\nimport {\n  MessageFilterSchema,\n  MessageCreateSchema,\n  MessageReplySchema,\n} from '../validation/message-schemas';\nimport {\n  PipelineFilterSchema,\n  PipelineCreateSchema,\n  PipelineUpdateSchema,\n} from '../validation/pipeline-schemas';\nimport {\n  PluginFilterSchema,\n  PluginCreateSchema,\n  PluginUpdateSchema,\n  PluginUploadBodySchema,\n} from '../validation/plugin-schemas';\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('AccessModifier', AccessModifierSchema.openapi({\n    description: 'Resource visibility: \"public\" (visible to all) or \"private\" (organization only)',\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"]}

package/lib/routes/health.d.ts

@@ -0,0 +1,47 @@
+import { Request, Response, Router } from 'express';
+/**
+ * Options for health check endpoint.
+ */
+export interface HealthCheckOptions {
+    /** Service name */
+    serviceName: string;
+    /** Service version (optional) */
+    version?: string;
+    /** Custom health check function for dependencies */
+    checkDependencies?: () => Promise<Record<string, 'connected' | 'disconnected' | 'unknown'>>;
+}
+/**
+ * Create a health check request handler.
+ *
+ * @param options - Health check options
+ * @returns Express request handler
+ *
+ * @example
+ * ```typescript
+ * app.get('/health', createHealthCheck({
+ *   serviceName: 'get-plugin',
+ *   version: '1.0.0',
+ *   checkDependencies: async () => ({
+ *     database: dbConnection.isConnected() ? 'connected' : 'disconnected',
+ *   }),
+ * }));
+ * ```
+ */
+export declare function createHealthCheck(options: HealthCheckOptions): (_req: Request, res: Response) => Promise<void>;
+/**
+ * Create a health check router with /health endpoint.
+ *
+ * @param options - Health check options
+ * @returns Express router with health endpoint
+ *
+ * @example
+ * ```typescript
+ * const healthRouter = createHealthRouter({
+ *   serviceName: 'get-plugin',
+ * });
+ *
+ * app.use(healthRouter);
+ * // Endpoint available at GET /health
+ * ```
+ */
+export declare function createHealthRouter(options: HealthCheckOptions): Router;

package/lib/routes/health.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHealthCheck = createHealthCheck;
+exports.createHealthRouter = createHealthRouter;
+const express_1 = require("express");
+const response_1 = require("../utils/response");
+const startTime = Date.now();
+/**
+ * Create a health check request handler.
+ *
+ * @param options - Health check options
+ * @returns Express request handler
+ *
+ * @example
+ * ```typescript
+ * app.get('/health', createHealthCheck({
+ *   serviceName: 'get-plugin',
+ *   version: '1.0.0',
+ *   checkDependencies: async () => ({
+ *     database: dbConnection.isConnected() ? 'connected' : 'disconnected',
+ *   }),
+ * }));
+ * ```
+ */
+function createHealthCheck(options) {
+    return async (_req, res) => {
+        const { serviceName, version, checkDependencies } = options;
+        const response = {
+            status: 'healthy',
+            service: serviceName,
+            timestamp: new Date().toISOString(),
+            uptime: Math.floor((Date.now() - startTime) / 1000),
+        };
+        if (version) {
+            response.version = version;
+        }
+        if (checkDependencies) {
+            try {
+                response.dependencies = await checkDependencies();
+                // Mark as unhealthy if any dependency is disconnected
+                const hasDisconnected = Object.values(response.dependencies).some((status) => status === 'disconnected');
+                if (hasDisconnected) {
+                    response.status = 'unhealthy';
+                    (0, response_1.sendError)(res, 503, 'Service unhealthy', undefined, response);
+                    return;
+                }
+            }
+            catch (error) {
+                response.status = 'unhealthy';
+                response.dependencies = { check: 'disconnected' };
+                (0, response_1.sendError)(res, 503, 'Service unhealthy', undefined, response);
+                return;
+            }
+        }
+        (0, response_1.sendSuccess)(res, 200, response);
+    };
+}
+/**
+ * Create a health check router with /health endpoint.
+ *
+ * @param options - Health check options
+ * @returns Express router with health endpoint
+ *
+ * @example
+ * ```typescript
+ * const healthRouter = createHealthRouter({
+ *   serviceName: 'get-plugin',
+ * });
+ *
+ * app.use(healthRouter);
+ * // Endpoint available at GET /health
+ * ```
+ */
+function createHealthRouter(options) {
+    const router = (0, express_1.Router)();
+    router.get('/health', createHealthCheck(options));
+    return router;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/routes/index.d.ts

@@ -0,0 +1 @@
+export * from './health';

package/lib/routes/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./health"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcm91dGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDOzs7Ozs7Ozs7Ozs7Ozs7O0FBRXRDLDJDQUF5QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2hlYWx0aCc7XG4iXX0=

package/lib/services/admin-audit.d.ts

@@ -0,0 +1,13 @@
+export interface AuditEntry {
+    userId: string;
+    userEmail?: string;
+    orgId?: string;
+    action: string;
+    targetType: string;
+    targetId?: string;
+    targetName?: string;
+    detail?: Record<string, unknown>;
+    ipAddress?: string;
+}
+export declare function logAdminAction(entry: AuditEntry): void;
+export declare function getAuditQueue(): AuditEntry[];