@pipeline-builder/api-core 0.0.1

package/lib/utils/ssrf.js

@@ -0,0 +1,106 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared SSRF guard for user/tenant-supplied outbound URLs (webhook targets,
+ * callbacks, …). Promoted to api-core so every service that lets an org point
+ * the platform at an arbitrary URL enforces the SAME denylist instead of each
+ * re-deriving it (the compliance notifier and the platform alert relay both
+ * consume this).
+ *
+ * The guard resolves the host up front and rejects any address that is — or
+ * resolves to — a loopback / private / link-local / unique-local / carrier-grade
+ * NAT / cloud-metadata range, so a tenant can't aim a webhook at
+ * `169.254.169.254` or an in-cluster service.
+ *
+ * DNS-rebinding note: the up-front resolve validates the *initial* host only.
+ * Node's global `fetch` (undici) re-resolves DNS for a redirect target
+ * independently, so callers MUST send with `redirect: 'manual'` and treat any
+ * 3xx as a failed delivery — see {@link SSRF_FETCH_INIT}. Pinning the exact
+ * resolved IP for the connection would need a custom undici dispatcher (not a
+ * dependency here); refusing redirects closes the practical rebinding pivot.
+ */
+import { lookup } from 'dns/promises';
+import { isIP } from 'net';
+/**
+ * True for loopback / private / link-local / CGNAT / cloud-metadata / ULA
+ * addresses — the ranges an outbound tenant webhook must never reach.
+ */
+export function isPrivateAddress(ip) {
+    const addr = ip.replace(/^\[|\]$/g, '').toLowerCase();
+    const v4 = addr.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (v4) {
+        const a = Number(v4[1]), b = Number(v4[2]);
+        return a === 0 || a === 10 || a === 127
+            || (a === 169 && b === 254) // link-local incl. 169.254.169.254 metadata
+            || (a === 172 && b >= 16 && b <= 31)
+            || (a === 192 && b === 168)
+            || (a === 100 && b >= 64 && b <= 127); // CGNAT
+    }
+    if (addr === '::1' || addr === '::')
+        return true;
+    if (addr.startsWith('::ffff:')) {
+        const suffix = addr.slice(7);
+        // Dotted form (`::ffff:127.0.0.1`) — recurse straight into the v4 checks.
+        if (suffix.includes('.'))
+            return isPrivateAddress(suffix);
+        // Hex form (`::ffff:7f00:1` = 127.0.0.1, `::ffff:c0a8:1` = 192.168.0.1):
+        // the low 32 bits are written as the last one/two hex groups. Fold them into
+        // a dotted quad and recurse so the v4 ranges below still catch it — without
+        // this the hex form slips past every check and reaches loopback/private space.
+        const groups = suffix.split(':');
+        const high = parseInt(groups[groups.length - 2] ?? '0', 16);
+        const low = parseInt(groups[groups.length - 1] ?? '0', 16);
+        if (Number.isNaN(high) || Number.isNaN(low))
+            return false;
+        // Fold each 16-bit half into two octets (arithmetic, not bitwise, to satisfy
+        // the no-bitwise lint): high → a.b, low → c.d.
+        const dotted = `${Math.floor(high / 256) % 256}.${high % 256}.${Math.floor(low / 256) % 256}.${low % 256}`;
+        return isPrivateAddress(dotted);
+    }
+    return addr.startsWith('fc') || addr.startsWith('fd') // unique-local
+        || addr.startsWith('fe80'); // link-local
+}
+/**
+ * Reject a URL that is malformed, uses a disallowed protocol, or points at a
+ * private/loopback/link-local/metadata address (by IP literal or by DNS
+ * resolution). Throws a plain `Error` with a caller-safe message on rejection;
+ * resolves silently when the URL is safe to fetch.
+ */
+export async function assertSafeUrl(rawUrl, opts = {}) {
+    const protocols = opts.protocols ?? ['https:'];
+    let u;
+    try {
+        u = new URL(rawUrl);
+    }
+    catch {
+        throw new Error('invalid url');
+    }
+    if (!protocols.includes(u.protocol)) {
+        throw new Error(`url must use ${protocols.map((p) => p.replace(/:$/, '')).join('/')}`);
+    }
+    const host = u.hostname;
+    if (isIP(host) && isPrivateAddress(host))
+        throw new Error('url targets a private address');
+    let addrs;
+    try {
+        addrs = await lookup(host, { all: true });
+    }
+    catch {
+        throw new Error('url host did not resolve');
+    }
+    if (addrs.length === 0)
+        throw new Error('url host did not resolve');
+    if (addrs.some((a) => isPrivateAddress(a.address)))
+        throw new Error('url resolves to a private address');
+}
+/**
+ * `fetch` init fragment every SSRF-guarded call MUST spread so a redirect can't
+ * pivot to an unvalidated (and re-resolved) host. Callers treat a 3xx / opaque
+ * redirect response as a failed delivery rather than following it.
+ */
+export const SSRF_FETCH_INIT = { redirect: 'manual' };
+/** True when a `fetch` Response is (or was) a redirect the caller must refuse. */
+export function isRefusedRedirect(resp) {
+    return resp.type === 'opaqueredirect' || (resp.status >= 300 && resp.status < 400);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ssrf.js","sourceRoot":"","sources":["../../src/utils/ssrf.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared SSRF guard for user/tenant-supplied outbound URLs (webhook targets,\n * callbacks, …). Promoted to api-core so every service that lets an org point\n * the platform at an arbitrary URL enforces the SAME denylist instead of each\n * re-deriving it (the compliance notifier and the platform alert relay both\n * consume this).\n *\n * The guard resolves the host up front and rejects any address that is — or\n * resolves to — a loopback / private / link-local / unique-local / carrier-grade\n * NAT / cloud-metadata range, so a tenant can't aim a webhook at\n * `169.254.169.254` or an in-cluster service.\n *\n * DNS-rebinding note: the up-front resolve validates the *initial* host only.\n * Node's global `fetch` (undici) re-resolves DNS for a redirect target\n * independently, so callers MUST send with `redirect: 'manual'` and treat any\n * 3xx as a failed delivery — see {@link SSRF_FETCH_INIT}. Pinning the exact\n * resolved IP for the connection would need a custom undici dispatcher (not a\n * dependency here); refusing redirects closes the practical rebinding pivot.\n */\n\nimport { lookup } from 'dns/promises';\nimport { isIP } from 'net';\n\n/**\n * True for loopback / private / link-local / CGNAT / cloud-metadata / ULA\n * addresses — the ranges an outbound tenant webhook must never reach.\n */\nexport function isPrivateAddress(ip: string): boolean {\n  const addr = ip.replace(/^\\[|\\]$/g, '').toLowerCase();\n  const v4 = addr.match(/^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/);\n  if (v4) {\n    const a = Number(v4[1]), b = Number(v4[2]);\n    return a === 0 || a === 10 || a === 127\n      || (a === 169 && b === 254) // link-local incl. 169.254.169.254 metadata\n      || (a === 172 && b >= 16 && b <= 31)\n      || (a === 192 && b === 168)\n      || (a === 100 && b >= 64 && b <= 127); // CGNAT\n  }\n  if (addr === '::1' || addr === '::') return true;\n  if (addr.startsWith('::ffff:')) {\n    const suffix = addr.slice(7);\n    // Dotted form (`::ffff:127.0.0.1`) — recurse straight into the v4 checks.\n    if (suffix.includes('.')) return isPrivateAddress(suffix);\n    // Hex form (`::ffff:7f00:1` = 127.0.0.1, `::ffff:c0a8:1` = 192.168.0.1):\n    // the low 32 bits are written as the last one/two hex groups. Fold them into\n    // a dotted quad and recurse so the v4 ranges below still catch it — without\n    // this the hex form slips past every check and reaches loopback/private space.\n    const groups = suffix.split(':');\n    const high = parseInt(groups[groups.length - 2] ?? '0', 16);\n    const low = parseInt(groups[groups.length - 1] ?? '0', 16);\n    if (Number.isNaN(high) || Number.isNaN(low)) return false;\n    // Fold each 16-bit half into two octets (arithmetic, not bitwise, to satisfy\n    // the no-bitwise lint): high → a.b, low → c.d.\n    const dotted = `${Math.floor(high / 256) % 256}.${high % 256}.${Math.floor(low / 256) % 256}.${low % 256}`;\n    return isPrivateAddress(dotted);\n  }\n  return addr.startsWith('fc') || addr.startsWith('fd') // unique-local\n    || addr.startsWith('fe80'); // link-local\n}\n\n/** Options for {@link assertSafeUrl}. */\nexport interface SafeUrlOptions {\n  /** Allowed URL protocols (default: `['https:']`). */\n  protocols?: string[];\n}\n\n/**\n * Reject a URL that is malformed, uses a disallowed protocol, or points at a\n * private/loopback/link-local/metadata address (by IP literal or by DNS\n * resolution). Throws a plain `Error` with a caller-safe message on rejection;\n * resolves silently when the URL is safe to fetch.\n */\nexport async function assertSafeUrl(rawUrl: string, opts: SafeUrlOptions = {}): Promise<void> {\n  const protocols = opts.protocols ?? ['https:'];\n  let u: URL;\n  try { u = new URL(rawUrl); } catch { throw new Error('invalid url'); }\n  if (!protocols.includes(u.protocol)) {\n    throw new Error(`url must use ${protocols.map((p) => p.replace(/:$/, '')).join('/')}`);\n  }\n  const host = u.hostname;\n  if (isIP(host) && isPrivateAddress(host)) throw new Error('url targets a private address');\n  let addrs: { address: string }[];\n  try { addrs = await lookup(host, { all: true }); } catch { throw new Error('url host did not resolve'); }\n  if (addrs.length === 0) throw new Error('url host did not resolve');\n  if (addrs.some((a) => isPrivateAddress(a.address))) throw new Error('url resolves to a private address');\n}\n\n/**\n * `fetch` init fragment every SSRF-guarded call MUST spread so a redirect can't\n * pivot to an unvalidated (and re-resolved) host. Callers treat a 3xx / opaque\n * redirect response as a failed delivery rather than following it.\n */\nexport const SSRF_FETCH_INIT = { redirect: 'manual' as const };\n\n/** True when a `fetch` Response is (or was) a redirect the caller must refuse. */\nexport function isRefusedRedirect(resp: { type?: string; status: number }): boolean {\n  return resp.type === 'opaqueredirect' || (resp.status >= 300 && resp.status < 400);\n}\n"]}

package/lib/validation/ai-schemas.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+/**
+ * Schema for AI generation request body.
+ * Used by both POST /pipelines/generate and POST /plugins/generate.
+ */
+export declare const AIGenerateBodySchema: z.ZodObject<{
+    prompt: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    previousConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    fallbackProviders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Schema for POST /plugins/deploy-generated request body.
+ * Validates the AI-generated plugin configuration before Docker build.
+ */
+export declare const PluginDeployGeneratedSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    pluginType: z.ZodDefault<z.ZodEnum<{
+        CodeBuildStep: "CodeBuildStep";
+        ManualApprovalStep: "ManualApprovalStep";
+        ShellStep: "ShellStep";
+    }>>;
+    computeType: z.ZodDefault<z.ZodEnum<{
+        LARGE: "LARGE";
+        MEDIUM: "MEDIUM";
+        SMALL: "SMALL";
+        X2_LARGE: "X2_LARGE";
+    }>>;
+    keywords: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    primaryOutputDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    installCommands: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    commands: z.ZodArray<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    buildArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    dockerfile: z.ZodString;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        org: "org";
+        private: "private";
+        public: "public";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Schema for POST /pipelines/generate/from-url/stream request body.
+ * Validates Git URL + AI provider configuration for repo-based pipeline generation.
+ */
+export declare const AIGenerateFromUrlBodySchema: z.ZodObject<{
+    gitUrl: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    repoToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/lib/validation/ai-schemas.js

@@ -0,0 +1,78 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+import { VisibilitySchema } from './common-schemas.js';
+const MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);
+// AI Generation Request
+/**
+ * Schema for AI generation request body.
+ * Used by both POST /pipelines/generate and POST /plugins/generate.
+ */
+export const AIGenerateBodySchema = z.object({
+    /** Natural language description of what to generate. */
+    prompt: z
+        .string()
+        .min(1, 'A prompt with a natural language description is required')
+        .max(MAX_PROMPT_LENGTH, `Prompt must be ${MAX_PROMPT_LENGTH} characters or fewer`),
+    /** AI provider identifier (e.g. "anthropic", "openai", "google"). */
+    provider: z.string().min(1, 'A provider is required (e.g., "anthropic", "openai", "google")'),
+    /** AI model identifier (e.g. "claude-sonnet-5", "gpt-4o"). */
+    model: z.string().min(1, 'A model is required (e.g., "claude-sonnet-5", "gpt-4o")'),
+    /** Optional custom API key to override the server/org key for this request. */
+    apiKey: z.string().min(1).optional(),
+    /** Previous pipeline config for iterative refinement. */
+    previousConfig: z.record(z.string(), z.unknown()).optional(),
+    /** Fallback AI providers if primary fails (e.g., ["openai", "google"]). */
+    fallbackProviders: z.array(z.string()).optional(),
+});
+// Plugin Deploy-Generated Request
+/**
+ * Schema for POST /plugins/deploy-generated request body.
+ * Validates the AI-generated plugin configuration before Docker build.
+ */
+export const PluginDeployGeneratedSchema = z.object({
+    /** Plugin name (lowercase, alphanumeric with hyphens). */
+    name: z.string().min(1, 'Plugin name is required'),
+    /** Human-readable description. */
+    description: z.string().optional(),
+    /** Semantic version (e.g. "1.0.0"). */
+    version: z.string().min(1, 'Version is required'),
+    /** Plugin execution type. */
+    pluginType: z.enum(['CodeBuildStep', 'ShellStep', 'ManualApprovalStep']).default('CodeBuildStep'),
+    /** AWS CodeBuild compute size. */
+    computeType: z.enum(['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE']).default('MEDIUM'),
+    /** Keywords for categorization. */
+    keywords: z.array(z.string()).optional().default([]),
+    /** Primary output directory path. */
+    primaryOutputDirectory: z.string().nullable().optional(),
+    /** Commands to install dependencies. */
+    installCommands: z.array(z.string()).optional().default([]),
+    /** Build/execution commands. */
+    commands: z.array(z.string()).min(1, 'At least one build command is required'),
+    /** Environment variables. */
+    env: z.record(z.string(), z.string()).optional(),
+    /** Docker build arguments passed via --build-arg at image build time. */
+    buildArgs: z.record(z.string(), z.string()).optional(),
+    /** Complete Dockerfile content for the build environment. */
+    dockerfile: z.string().min(1, 'Dockerfile content is required'),
+    /** Access visibility. */
+    visibility: VisibilitySchema.default('private'),
+});
+// AI Generate From URL Request
+/**
+ * Schema for POST /pipelines/generate/from-url/stream request body.
+ * Validates Git URL + AI provider configuration for repo-based pipeline generation.
+ */
+export const AIGenerateFromUrlBodySchema = z.object({
+    /** Git repository URL (HTTPS, SSH, or git@ format). */
+    gitUrl: z.string().min(1, 'A Git repository URL is required').max(500, 'URL must be 500 characters or fewer'),
+    /** AI provider identifier (e.g. "anthropic", "openai", "google"). */
+    provider: z.string().min(1, 'A provider is required'),
+    /** AI model identifier (e.g. "claude-sonnet-5", "gpt-4o"). */
+    model: z.string().min(1, 'A model is required'),
+    /** Optional custom API key to override the server config. */
+    apiKey: z.string().min(1).optional(),
+    /** Optional authentication token for accessing private repositories. */
+    repoToken: z.string().min(1).optional(),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-schemas.js","sourceRoot":"","sources":["../../src/validation/ai-schemas.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';\nimport { VisibilitySchema } from './common-schemas.js';\n\nconst MAX_PROMPT_LENGTH = parseInt(process.env.MAX_PROMPT_LENGTH || '5000', 10);\n\n// AI Generation Request\n\n/**\n * Schema for AI generation request body.\n * Used by both POST /pipelines/generate and POST /plugins/generate.\n */\nexport const AIGenerateBodySchema = z.object({\n  /** Natural language description of what to generate. */\n  prompt: z\n    .string()\n    .min(1, 'A prompt with a natural language description is required')\n    .max(MAX_PROMPT_LENGTH, `Prompt must be ${MAX_PROMPT_LENGTH} characters or fewer`),\n\n  /** AI provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  provider: z.string().min(1, 'A provider is required (e.g., \"anthropic\", \"openai\", \"google\")'),\n\n  /** AI model identifier (e.g. \"claude-sonnet-5\", \"gpt-4o\"). */\n  model: z.string().min(1, 'A model is required (e.g., \"claude-sonnet-5\", \"gpt-4o\")'),\n\n  /** Optional custom API key to override the server/org key for this request. */\n  apiKey: z.string().min(1).optional(),\n\n  /** Previous pipeline config for iterative refinement. */\n  previousConfig: z.record(z.string(), z.unknown()).optional(),\n\n  /** Fallback AI providers if primary fails (e.g., [\"openai\", \"google\"]). */\n  fallbackProviders: z.array(z.string()).optional(),\n});\n\n// Plugin Deploy-Generated Request\n\n/**\n * Schema for POST /plugins/deploy-generated request body.\n * Validates the AI-generated plugin configuration before Docker build.\n */\nexport const PluginDeployGeneratedSchema = z.object({\n  /** Plugin name (lowercase, alphanumeric with hyphens). */\n  name: z.string().min(1, 'Plugin name is required'),\n\n  /** Human-readable description. */\n  description: z.string().optional(),\n\n  /** Semantic version (e.g. \"1.0.0\"). */\n  version: z.string().min(1, 'Version is required'),\n\n  /** Plugin execution type. */\n  pluginType: z.enum(['CodeBuildStep', 'ShellStep', 'ManualApprovalStep']).default('CodeBuildStep'),\n\n  /** AWS CodeBuild compute size. */\n  computeType: z.enum(['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE']).default('MEDIUM'),\n\n  /** Keywords for categorization. */\n  keywords: z.array(z.string()).optional().default([]),\n\n  /** Primary output directory path. */\n  primaryOutputDirectory: z.string().nullable().optional(),\n\n  /** Commands to install dependencies. */\n  installCommands: z.array(z.string()).optional().default([]),\n\n  /** Build/execution commands. */\n  commands: z.array(z.string()).min(1, 'At least one build command is required'),\n\n  /** Environment variables. */\n  env: z.record(z.string(), z.string()).optional(),\n\n  /** Docker build arguments passed via --build-arg at image build time. */\n  buildArgs: z.record(z.string(), z.string()).optional(),\n\n  /** Complete Dockerfile content for the build environment. */\n  dockerfile: z.string().min(1, 'Dockerfile content is required'),\n\n  /** Access visibility. */\n  visibility: VisibilitySchema.default('private'),\n});\n\n// AI Generate From URL Request\n\n/**\n * Schema for POST /pipelines/generate/from-url/stream request body.\n * Validates Git URL + AI provider configuration for repo-based pipeline generation.\n */\nexport const AIGenerateFromUrlBodySchema = z.object({\n  /** Git repository URL (HTTPS, SSH, or git@ format). */\n  gitUrl: z.string().min(1, 'A Git repository URL is required').max(500, 'URL must be 500 characters or fewer'),\n\n  /** AI provider identifier (e.g. \"anthropic\", \"openai\", \"google\"). */\n  provider: z.string().min(1, 'A provider is required'),\n\n  /** AI model identifier (e.g. \"claude-sonnet-5\", \"gpt-4o\"). */\n  model: z.string().min(1, 'A model is required'),\n\n  /** Optional custom API key to override the server config. */\n  apiKey: z.string().min(1).optional(),\n\n  /** Optional authentication token for accessing private repositories. */\n  repoToken: z.string().min(1).optional(),\n});\n"]}

package/lib/validation/common-schemas.d.ts

@@ -0,0 +1,133 @@
+import '../openapi/extend-zod.js';
+import { z } from 'zod';
+/** The shared three-rung sharing ladder — see the `Visibility` type. */
+export declare const VisibilitySchema: z.ZodEnum<{
+    org: "org";
+    private: "private";
+    public: "public";
+}>;
+/**
+ * Developer-portal catalog-metadata schemas — shared by pipeline and plugin
+ * create/update bodies (and the filter schema below). Mirror the shared types
+ * in `types/catalog-metadata.ts`.
+ */
+export declare const LifecycleSchema: z.ZodEnum<{
+    deprecated: "deprecated";
+    experimental: "experimental";
+    production: "production";
+}>;
+export declare const CriticalitySchema: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    low: "low";
+    medium: "medium";
+}>;
+export declare const OwnerTypeSchema: z.ZodEnum<{
+    team: "team";
+    user: "user";
+}>;
+export declare const EntityLinkSchema: z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodString;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Typed classification labels: `{ team: 'payments', tier: 'gold' }`. */
+export declare const EntityLabelsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/**
+ * Catalog-metadata fields common to catalog entities. Spread into create/update
+ * body schemas so pipelines and plugins accept identical ownership/lifecycle/
+ * classification input. All optional — owner defaults to the creator server-side.
+ */
+export declare const CatalogMetadataShape: {
+    readonly ownerId: z.ZodOptional<z.ZodString>;
+    readonly ownerType: z.ZodOptional<z.ZodEnum<{
+        team: "team";
+        user: "user";
+    }>>;
+    readonly lifecycle: z.ZodOptional<z.ZodEnum<{
+        deprecated: "deprecated";
+        experimental: "experimental";
+        production: "production";
+    }>>;
+    readonly criticality: z.ZodOptional<z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>>;
+    readonly labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    readonly links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        url: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+};
+/**
+ * Sort order schema
+ */
+export declare const SortOrderSchema: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+}>;
+/**
+ * Pagination parameters schema.
+ *
+ * `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` are the SINGLE source for these values
+ * across the monorepo — pipeline-core's `CoreConstants` and pipeline-data's
+ * `CrudService` import them from here instead of re-reading the env (which drifted).
+ */
+export declare const MAX_PAGE_LIMIT: number;
+export declare const DEFAULT_PAGE_LIMIT: number;
+/** Ceiling on offset-based paging — beyond this, deep paging must use the cursor API
+ *  (an unbounded offset is a scan-and-discard DoS amplifier on hot list routes). */
+export declare const MAX_PAGE_OFFSET: number;
+export declare const PaginationSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    sortBy: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Boolean query parameter schema
+ * Handles string "true"/"false" and boolean values
+ */
+export declare const BooleanQuerySchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+    false: "false";
+    true: "true";
+}>, z.ZodTransform<boolean, "false" | "true">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>;
+/**
+ * UUID schema with validation
+ */
+export declare const UUIDSchema: z.ZodString;
+/**
+ * Optional UUID schema (for partial UUIDs or prefixes)
+ */
+export declare const UUIDPrefixSchema: z.ZodString;
+/**
+ * Base filter schema for entities with common fields
+ */
+export declare const BaseFilterSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodString]>>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        org: "org";
+        private: "private";
+        public: "public";
+    }>>;
+    isActive: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>, z.ZodTransform<boolean, "false" | "true">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    isDefault: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>, z.ZodTransform<boolean, "false" | "true">>, z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>]>>;
+    ownerId: z.ZodOptional<z.ZodString>;
+    lifecycle: z.ZodOptional<z.ZodEnum<{
+        deprecated: "deprecated";
+        experimental: "experimental";
+        production: "production";
+    }>>;
+}, z.core.$strip>;

package/lib/validation/common-schemas.js

@@ -0,0 +1,94 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// Must run before any z.* schema creation — Zod 4 requires eager extension
+import '../openapi/extend-zod.js';
+import { z } from 'zod';
+import { VISIBILITIES } from '../types/visibility.js';
+import { envInt } from '../utils/env.js';
+/** The shared three-rung sharing ladder — see the `Visibility` type. */
+export const VisibilitySchema = z.enum(VISIBILITIES);
+/**
+ * Developer-portal catalog-metadata schemas — shared by pipeline and plugin
+ * create/update bodies (and the filter schema below). Mirror the shared types
+ * in `types/catalog-metadata.ts`.
+ */
+export const LifecycleSchema = z.enum(['experimental', 'production', 'deprecated']);
+export const CriticalitySchema = z.enum(['low', 'medium', 'high', 'critical']);
+export const OwnerTypeSchema = z.enum(['user', 'team']);
+export const EntityLinkSchema = z.object({
+    title: z.string().min(1).max(120),
+    url: z.string().url().max(2048),
+    icon: z.string().max(40).optional(),
+});
+/** Typed classification labels: `{ team: 'payments', tier: 'gold' }`. */
+export const EntityLabelsSchema = z.record(z.string().min(1).max(63), z.string().max(255));
+/**
+ * Catalog-metadata fields common to catalog entities. Spread into create/update
+ * body schemas so pipelines and plugins accept identical ownership/lifecycle/
+ * classification input. All optional — owner defaults to the creator server-side.
+ */
+export const CatalogMetadataShape = {
+    ownerId: z.string().min(1).max(255).optional(),
+    ownerType: OwnerTypeSchema.optional(),
+    lifecycle: LifecycleSchema.optional(),
+    criticality: CriticalitySchema.optional(),
+    labels: EntityLabelsSchema.optional(),
+    links: z.array(EntityLinkSchema).max(50).optional(),
+};
+/**
+ * Sort order schema
+ */
+export const SortOrderSchema = z.enum(['asc', 'desc']);
+/**
+ * Pagination parameters schema.
+ *
+ * `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` are the SINGLE source for these values
+ * across the monorepo — pipeline-core's `CoreConstants` and pipeline-data's
+ * `CrudService` import them from here instead of re-reading the env (which drifted).
+ */
+export const MAX_PAGE_LIMIT = envInt('MAX_PAGE_LIMIT', 1000, { min: 1 });
+export const DEFAULT_PAGE_LIMIT = envInt('DEFAULT_PAGE_LIMIT', 100, { min: 1 });
+/** Ceiling on offset-based paging — beyond this, deep paging must use the cursor API
+ *  (an unbounded offset is a scan-and-discard DoS amplifier on hot list routes). */
+export const MAX_PAGE_OFFSET = envInt('MAX_PAGE_OFFSET', 100000, { min: 0 });
+export const PaginationSchema = z.object({
+    limit: z.coerce.number().int().min(1).max(MAX_PAGE_LIMIT).optional(),
+    offset: z.coerce.number().int().min(0).optional(),
+    sortBy: z.string().optional(),
+    sortOrder: SortOrderSchema.optional(),
+});
+/**
+ * Boolean query parameter schema
+ * Handles string "true"/"false" and boolean values
+ */
+export const BooleanQuerySchema = z.union([
+    z.boolean(),
+    z.enum(['true', 'false']).transform(val => val === 'true'),
+    z.string().transform(val => val === 'true'),
+]);
+/**
+ * UUID schema with validation
+ */
+export const UUIDSchema = z.string().uuid({
+    message: 'Invalid UUID format',
+});
+/**
+ * Optional UUID schema (for partial UUIDs or prefixes)
+ */
+export const UUIDPrefixSchema = z.string().regex(/^[0-9a-f-]+$/i, {
+    message: 'Invalid UUID prefix format',
+});
+/**
+ * Base filter schema for entities with common fields
+ */
+export const BaseFilterSchema = z.object({
+    id: z.union([UUIDSchema, z.array(UUIDSchema), UUIDPrefixSchema]).optional(),
+    visibility: VisibilitySchema.optional(),
+    isActive: BooleanQuerySchema.optional(),
+    isDefault: BooleanQuerySchema.optional(),
+    // Developer-portal catalog filters (applied only by entities that carry
+    // owner/lifecycle columns — pipelines and plugins).
+    ownerId: z.string().min(1).optional(),
+    lifecycle: LifecycleSchema.optional(),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-schemas.js","sourceRoot":"","sources":["../../src/validation/common-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n// Must run before any z.* schema creation — Zod 4 requires eager extension\nimport '../openapi/extend-zod.js';\nimport { z } from 'zod';\nimport { VISIBILITIES } from '../types/visibility.js';\nimport { envInt } from '../utils/env.js';\n\n/** The shared three-rung sharing ladder — see the `Visibility` type. */\nexport const VisibilitySchema = z.enum(VISIBILITIES);\n\n/**\n * Developer-portal catalog-metadata schemas — shared by pipeline and plugin\n * create/update bodies (and the filter schema below). Mirror the shared types\n * in `types/catalog-metadata.ts`.\n */\nexport const LifecycleSchema = z.enum(['experimental', 'production', 'deprecated']);\nexport const CriticalitySchema = z.enum(['low', 'medium', 'high', 'critical']);\nexport const OwnerTypeSchema = z.enum(['user', 'team']);\n\nexport const EntityLinkSchema = z.object({\n  title: z.string().min(1).max(120),\n  url: z.string().url().max(2048),\n  icon: z.string().max(40).optional(),\n});\n\n/** Typed classification labels: `{ team: 'payments', tier: 'gold' }`. */\nexport const EntityLabelsSchema = z.record(z.string().min(1).max(63), z.string().max(255));\n\n/**\n * Catalog-metadata fields common to catalog entities. Spread into create/update\n * body schemas so pipelines and plugins accept identical ownership/lifecycle/\n * classification input. All optional — owner defaults to the creator server-side.\n */\nexport const CatalogMetadataShape = {\n  ownerId: z.string().min(1).max(255).optional(),\n  ownerType: OwnerTypeSchema.optional(),\n  lifecycle: LifecycleSchema.optional(),\n  criticality: CriticalitySchema.optional(),\n  labels: EntityLabelsSchema.optional(),\n  links: z.array(EntityLinkSchema).max(50).optional(),\n} as const;\n\n/**\n * Sort order schema\n */\nexport const SortOrderSchema = z.enum(['asc', 'desc']);\n\n/**\n * Pagination parameters schema.\n *\n * `MAX_PAGE_LIMIT` / `DEFAULT_PAGE_LIMIT` are the SINGLE source for these values\n * across the monorepo — pipeline-core's `CoreConstants` and pipeline-data's\n * `CrudService` import them from here instead of re-reading the env (which drifted).\n */\nexport const MAX_PAGE_LIMIT = envInt('MAX_PAGE_LIMIT', 1000, { min: 1 });\nexport const DEFAULT_PAGE_LIMIT = envInt('DEFAULT_PAGE_LIMIT', 100, { min: 1 });\n/** Ceiling on offset-based paging — beyond this, deep paging must use the cursor API\n *  (an unbounded offset is a scan-and-discard DoS amplifier on hot list routes). */\nexport const MAX_PAGE_OFFSET = envInt('MAX_PAGE_OFFSET', 100000, { min: 0 });\n\nexport const PaginationSchema = z.object({\n  limit: z.coerce.number().int().min(1).max(MAX_PAGE_LIMIT).optional(),\n  offset: z.coerce.number().int().min(0).optional(),\n  sortBy: z.string().optional(),\n  sortOrder: SortOrderSchema.optional(),\n});\n\n/**\n * Boolean query parameter schema\n * Handles string \"true\"/\"false\" and boolean values\n */\nexport const BooleanQuerySchema = z.union([\n  z.boolean(),\n  z.enum(['true', 'false']).transform(val => val === 'true'),\n  z.string().transform(val => val === 'true'),\n]);\n\n/**\n * UUID schema with validation\n */\nexport const UUIDSchema = z.string().uuid({\n  message: 'Invalid UUID format',\n});\n\n/**\n * Optional UUID schema (for partial UUIDs or prefixes)\n */\nexport const UUIDPrefixSchema = z.string().regex(/^[0-9a-f-]+$/i, {\n  message: 'Invalid UUID prefix format',\n});\n\n/**\n * Base filter schema for entities with common fields\n */\nexport const BaseFilterSchema = z.object({\n  id: z.union([UUIDSchema, z.array(UUIDSchema), UUIDPrefixSchema]).optional(),\n  visibility: VisibilitySchema.optional(),\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  // Developer-portal catalog filters (applied only by entities that carry\n  // owner/lifecycle columns — pipelines and plugins).\n  ownerId: z.string().min(1).optional(),\n  lifecycle: LifecycleSchema.optional(),\n});\n"]}

package/lib/validation/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common-schemas.js';
+export * from './pipeline-schemas.js';
+export * from './pipeline-template-schemas.js';
+export * from './plugin-schemas.js';
+export * from './message-schemas.js';
+export * from './ai-schemas.js';
+export * from './middleware.js';

package/lib/validation/index.js

@@ -0,0 +1,10 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './common-schemas.js';
+export * from './pipeline-schemas.js';
+export * from './pipeline-template-schemas.js';
+export * from './plugin-schemas.js';
+export * from './message-schemas.js';
+export * from './ai-schemas.js';
+export * from './middleware.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmFsaWRhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9jb21tb24tc2NoZW1hcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lLXNjaGVtYXMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlbGluZS10ZW1wbGF0ZS1zY2hlbWFzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcGx1Z2luLXNjaGVtYXMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tZXNzYWdlLXNjaGVtYXMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9haS1zY2hlbWFzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbWlkZGxld2FyZS5qcyc7XG4iXX0=