@pipeline-builder/api-core 4.1.13 → 4.1.15

package/lib/validation/dockerfile-static.js

@@ -0,0 +1,210 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * STATIC reading of a plugin's own Dockerfile (catalog detection and the
+ * `runAsRoot` compliance fact): its `LABEL` instructions and its final `USER`, without
+ * building anything.
+ *
+ * - Only the plugin's OWN instructions count. The built image's config also
+ *   carries every label inherited from its base image, and those describe the
+ *   base image, not the plugin — so labels are never read from an image.
+ * - Only the FINAL stage counts (plus any earlier stage it is built `FROM`):
+ *   labels and `USER` set in a discarded build stage never reach the image.
+ * - A value containing `$` is ignored: build arguments aren't known at upload,
+ *   so the static text is not what the image would carry.
+ * - Values are untrusted text, exactly like the spec.
+ *
+ * Handles the `# escape=` parser directive, line continuations (with comment
+ * lines inside a continuation skipped, as Docker does), `key=value` pairs with
+ * double quotes (backslash escapes) or single quotes (literal), and the legacy
+ * `LABEL key value` form.
+ */
+/** Max Dockerfile text read (bytes). Larger inputs are truncated, never parsed whole. */
+const MAX_DOCKERFILE_CHARS = 256 * 1024;
+/** The escape character from a leading `# escape=` directive (default `\`). */
+function escapeCharOf(lines) {
+    for (const line of lines) {
+        const t = line.trim();
+        if (t === '')
+            continue;
+        const m = /^#\s*escape\s*=\s*([`\\])\s*$/i.exec(t);
+        if (m)
+            return m[1];
+        // Parser directives must come first; any other directive-shaped comment is
+        // skipped, anything else ends the directive block.
+        if (!/^#\s*\w+\s*=/.test(t))
+            break;
+    }
+    return '\\';
+}
+/** Physical lines → logical instructions (continuations joined, comments dropped). */
+function logicalLines(content) {
+    const lines = content.slice(0, MAX_DOCKERFILE_CHARS).replace(/\r\n?/g, '\n').split('\n');
+    const esc = escapeCharOf(lines);
+    const out = [];
+    let current = null;
+    for (const raw of lines) {
+        const trimmed = raw.trim();
+        if (current === null && (trimmed === '' || trimmed.startsWith('#')))
+            continue;
+        // Docker skips comment and empty lines inside a continuation.
+        if (current !== null && (trimmed === '' || trimmed.startsWith('#')))
+            continue;
+        const continued = raw.replace(/\s+$/, '').endsWith(esc);
+        const body = continued ? raw.replace(/\s+$/, '').slice(0, -1) : raw;
+        current = current === null ? body : `${current}${body}`;
+        if (!continued) {
+            out.push(current.trim());
+            current = null;
+        }
+    }
+    if (current !== null && current.trim())
+        out.push(current.trim());
+    return out;
+}
+/**
+ * Split `LABEL` arguments into words, honouring double quotes (with backslash
+ * escapes) and single quotes (literal). Returns null on an unterminated quote.
+ */
+function splitWords(args) {
+    const words = [];
+    let word = '';
+    let inWord = false;
+    for (let i = 0; i < args.length; i++) {
+        const c = args[i];
+        if (c === '"') {
+            inWord = true;
+            let j = i + 1;
+            for (; j < args.length && args[j] !== '"'; j++) {
+                if (args[j] === '\\' && j + 1 < args.length)
+                    j++;
+                word += args[j];
+            }
+            if (j >= args.length)
+                return null;
+            i = j;
+        }
+        else if (c === '\'') {
+            inWord = true;
+            const end = args.indexOf('\'', i + 1);
+            if (end < 0)
+                return null;
+            word += args.slice(i + 1, end);
+            i = end;
+        }
+        else if (c === '\\' && i + 1 < args.length) {
+            inWord = true;
+            word += args[++i];
+        }
+        else if (/\s/.test(c)) {
+            if (inWord)
+                words.push(word);
+            word = '';
+            inWord = false;
+        }
+        else {
+            inWord = true;
+            word += c;
+        }
+    }
+    if (inWord)
+        words.push(word);
+    return words;
+}
+/** The `key → value` pairs of one `LABEL` instruction's arguments. */
+export function parseLabelArgs(args) {
+    const trimmed = args.trim();
+    // Legacy form: `LABEL key value with spaces` (no `=` in the first word).
+    const firstWord = /^\S+/.exec(trimmed)?.[0] ?? '';
+    if (firstWord && !firstWord.includes('=')) {
+        const words = splitWords(trimmed);
+        if (!words || words.length < 2)
+            return [];
+        return [[words[0], words.slice(1).join(' ')]];
+    }
+    const words = splitWords(trimmed);
+    if (!words)
+        return [];
+    const pairs = [];
+    for (const w of words) {
+        const eq = w.indexOf('=');
+        if (eq <= 0)
+            continue;
+        pairs.push([w.slice(0, eq), w.slice(eq + 1)]);
+    }
+    return pairs;
+}
+/** Parse what `content` declares for its final image. Never throws. */
+export function parseDockerfile(content) {
+    const stages = [];
+    for (const line of logicalLines(content ?? '')) {
+        const m = /^(\S+)\s*(.*)$/s.exec(line);
+        if (!m)
+            continue;
+        const instruction = m[1].toUpperCase();
+        const args = m[2] ?? '';
+        if (instruction === 'FROM') {
+            // FROM [--platform=…] <image> [AS <name>]
+            const words = args.split(/\s+/).filter((w) => w && !w.startsWith('--'));
+            const asIdx = words.findIndex((w) => w.toLowerCase() === 'as');
+            stages.push({
+                base: (words[0] ?? '').toLowerCase(),
+                rawBase: words[0] ?? '',
+                alias: asIdx >= 0 && words[asIdx + 1] ? words[asIdx + 1].toLowerCase() : null,
+                labels: new Map(),
+                user: null,
+            });
+            continue;
+        }
+        const stage = stages[stages.length - 1];
+        if (!stage)
+            continue; // Instructions before the first FROM (ARG) set nothing on the image.
+        if (instruction === 'LABEL') {
+            for (const [k, v] of parseLabelArgs(args)) {
+                if (v.includes('$') || k.includes('$')) {
+                    stage.labels.delete(k);
+                    continue;
+                }
+                stage.labels.set(k, v);
+            }
+        }
+        else if (instruction === 'USER') {
+            stage.user = args.trim() || null;
+        }
+    }
+    if (stages.length === 0)
+        return { labels: {}, finalUser: null, baseImage: null };
+    // The final stage, preceded by the chain of earlier stages it is built FROM
+    // (its own content, not a base image's), oldest first.
+    const chain = [];
+    let cursor = stages[stages.length - 1];
+    const seen = new Set();
+    while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        chain.unshift(cursor);
+        const base = cursor.base;
+        const idx = stages.indexOf(cursor);
+        cursor = stages.slice(0, idx).reverse().find((s) => s.alias !== null && s.alias === base);
+    }
+    const labels = {};
+    let finalUser = null;
+    for (const s of chain) {
+        for (const [k, v] of s.labels)
+            labels[k] = v;
+        if (s.user !== null)
+            finalUser = s.user;
+    }
+    const root = chain[0].rawBase;
+    const baseImage = root === '' || root.includes('$') || root.toLowerCase() === 'scratch' ? null : root;
+    return { labels, finalUser, baseImage };
+}
+/** The OCI annotation keys the catalog reads. */
+export const OCI_LABELS = {
+    title: 'org.opencontainers.image.title',
+    description: 'org.opencontainers.image.description',
+    licenses: 'org.opencontainers.image.licenses',
+    url: 'org.opencontainers.image.url',
+    source: 'org.opencontainers.image.source',
+    documentation: 'org.opencontainers.image.documentation',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dockerfile-static.js","sourceRoot":"","sources":["../../src/validation/dockerfile-static.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * STATIC reading of a plugin's own Dockerfile (catalog detection and the\n * `runAsRoot` compliance fact): its `LABEL` instructions and its final `USER`, without\n * building anything.\n *\n * - Only the plugin's OWN instructions count. The built image's config also\n *   carries every label inherited from its base image, and those describe the\n *   base image, not the plugin — so labels are never read from an image.\n * - Only the FINAL stage counts (plus any earlier stage it is built `FROM`):\n *   labels and `USER` set in a discarded build stage never reach the image.\n * - A value containing `$` is ignored: build arguments aren't known at upload,\n *   so the static text is not what the image would carry.\n * - Values are untrusted text, exactly like the spec.\n *\n * Handles the `# escape=` parser directive, line continuations (with comment\n * lines inside a continuation skipped, as Docker does), `key=value` pairs with\n * double quotes (backslash escapes) or single quotes (literal), and the legacy\n * `LABEL key value` form.\n */\n\n/** Max Dockerfile text read (bytes). Larger inputs are truncated, never parsed whole. */\nconst MAX_DOCKERFILE_CHARS = 256 * 1024;\n\ninterface Stage {\n  /** Lowercased `AS` alias, if any. */\n  alias: string | null;\n  /** Lowercased base reference (`FROM <base>`). */\n  base: string;\n  /** The base reference as written (image refs are case-sensitive in tags). */\n  rawBase: string;\n  labels: Map<string, string>;\n  /** Last `USER` in the stage (raw), or null when the stage sets none. */\n  user: string | null;\n}\n\n/** What the plugin's Dockerfile itself declares for its final image. */\nexport interface DockerfileFacts {\n  /** The final image's own labels (later instructions win). */\n  labels: Record<string, string>;\n  /** The final image's own `USER`, or null when the Dockerfile sets none. */\n  finalUser: string | null;\n  /**\n   * The external image the final stage is ultimately built `FROM` (following\n   * stage aliases), as written; null when there is no `FROM`, it is `scratch`,\n   * or it depends on a build argument (`$`), which isn't known statically.\n   */\n  baseImage: string | null;\n}\n\n/** The escape character from a leading `# escape=` directive (default `\\`). */\nfunction escapeCharOf(lines: string[]): string {\n  for (const line of lines) {\n    const t = line.trim();\n    if (t === '') continue;\n    const m = /^#\\s*escape\\s*=\\s*([`\\\\])\\s*$/i.exec(t);\n    if (m) return m[1]!;\n    // Parser directives must come first; any other directive-shaped comment is\n    // skipped, anything else ends the directive block.\n    if (!/^#\\s*\\w+\\s*=/.test(t)) break;\n  }\n  return '\\\\';\n}\n\n/** Physical lines → logical instructions (continuations joined, comments dropped). */\nfunction logicalLines(content: string): string[] {\n  const lines = content.slice(0, MAX_DOCKERFILE_CHARS).replace(/\\r\\n?/g, '\\n').split('\\n');\n  const esc = escapeCharOf(lines);\n  const out: string[] = [];\n  let current: string | null = null;\n  for (const raw of lines) {\n    const trimmed = raw.trim();\n    if (current === null && (trimmed === '' || trimmed.startsWith('#'))) continue;\n    // Docker skips comment and empty lines inside a continuation.\n    if (current !== null && (trimmed === '' || trimmed.startsWith('#'))) continue;\n    const continued = raw.replace(/\\s+$/, '').endsWith(esc);\n    const body = continued ? raw.replace(/\\s+$/, '').slice(0, -1) : raw;\n    current = current === null ? body : `${current}${body}`;\n    if (!continued) {\n      out.push(current.trim());\n      current = null;\n    }\n  }\n  if (current !== null && current.trim()) out.push(current.trim());\n  return out;\n}\n\n/**\n * Split `LABEL` arguments into words, honouring double quotes (with backslash\n * escapes) and single quotes (literal). Returns null on an unterminated quote.\n */\nfunction splitWords(args: string): string[] | null {\n  const words: string[] = [];\n  let word = '';\n  let inWord = false;\n  for (let i = 0; i < args.length; i++) {\n    const c = args[i]!;\n    if (c === '\"') {\n      inWord = true;\n      let j = i + 1;\n      for (; j < args.length && args[j] !== '\"'; j++) {\n        if (args[j] === '\\\\' && j + 1 < args.length) j++;\n        word += args[j];\n      }\n      if (j >= args.length) return null;\n      i = j;\n    } else if (c === '\\'') {\n      inWord = true;\n      const end = args.indexOf('\\'', i + 1);\n      if (end < 0) return null;\n      word += args.slice(i + 1, end);\n      i = end;\n    } else if (c === '\\\\' && i + 1 < args.length) {\n      inWord = true;\n      word += args[++i];\n    } else if (/\\s/.test(c)) {\n      if (inWord) words.push(word);\n      word = '';\n      inWord = false;\n    } else {\n      inWord = true;\n      word += c;\n    }\n  }\n  if (inWord) words.push(word);\n  return words;\n}\n\n/** The `key → value` pairs of one `LABEL` instruction's arguments. */\nexport function parseLabelArgs(args: string): Array<[string, string]> {\n  const trimmed = args.trim();\n  // Legacy form: `LABEL key value with spaces` (no `=` in the first word).\n  const firstWord = /^\\S+/.exec(trimmed)?.[0] ?? '';\n  if (firstWord && !firstWord.includes('=')) {\n    const words = splitWords(trimmed);\n    if (!words || words.length < 2) return [];\n    return [[words[0]!, words.slice(1).join(' ')]];\n  }\n  const words = splitWords(trimmed);\n  if (!words) return [];\n  const pairs: Array<[string, string]> = [];\n  for (const w of words) {\n    const eq = w.indexOf('=');\n    if (eq <= 0) continue;\n    pairs.push([w.slice(0, eq), w.slice(eq + 1)]);\n  }\n  return pairs;\n}\n\n/** Parse what `content` declares for its final image. Never throws. */\nexport function parseDockerfile(content: string | null | undefined): DockerfileFacts {\n  const stages: Stage[] = [];\n  for (const line of logicalLines(content ?? '')) {\n    const m = /^(\\S+)\\s*(.*)$/s.exec(line);\n    if (!m) continue;\n    const instruction = m[1]!.toUpperCase();\n    const args = m[2] ?? '';\n    if (instruction === 'FROM') {\n      // FROM [--platform=…] <image> [AS <name>]\n      const words = args.split(/\\s+/).filter((w) => w && !w.startsWith('--'));\n      const asIdx = words.findIndex((w) => w.toLowerCase() === 'as');\n      stages.push({\n        base: (words[0] ?? '').toLowerCase(),\n        rawBase: words[0] ?? '',\n        alias: asIdx >= 0 && words[asIdx + 1] ? words[asIdx + 1]!.toLowerCase() : null,\n        labels: new Map(),\n        user: null,\n      });\n      continue;\n    }\n    const stage = stages[stages.length - 1];\n    if (!stage) continue; // Instructions before the first FROM (ARG) set nothing on the image.\n    if (instruction === 'LABEL') {\n      for (const [k, v] of parseLabelArgs(args)) {\n        if (v.includes('$') || k.includes('$')) {\n          stage.labels.delete(k);\n          continue;\n        }\n        stage.labels.set(k, v);\n      }\n    } else if (instruction === 'USER') {\n      stage.user = args.trim() || null;\n    }\n  }\n\n  if (stages.length === 0) return { labels: {}, finalUser: null, baseImage: null };\n\n  // The final stage, preceded by the chain of earlier stages it is built FROM\n  // (its own content, not a base image's), oldest first.\n  const chain: Stage[] = [];\n  let cursor: Stage | undefined = stages[stages.length - 1];\n  const seen = new Set<Stage>();\n  while (cursor && !seen.has(cursor)) {\n    seen.add(cursor);\n    chain.unshift(cursor);\n    const base: string = cursor.base;\n    const idx = stages.indexOf(cursor);\n    cursor = stages.slice(0, idx).reverse().find((s) => s.alias !== null && s.alias === base);\n  }\n\n  const labels: Record<string, string> = {};\n  let finalUser: string | null = null;\n  for (const s of chain) {\n    for (const [k, v] of s.labels) labels[k] = v;\n    if (s.user !== null) finalUser = s.user;\n  }\n  const root = chain[0]!.rawBase;\n  const baseImage = root === '' || root.includes('$') || root.toLowerCase() === 'scratch' ? null : root;\n  return { labels, finalUser, baseImage };\n}\n\n/** The OCI annotation keys the catalog reads. */\nexport const OCI_LABELS = {\n  title: 'org.opencontainers.image.title',\n  description: 'org.opencontainers.image.description',\n  licenses: 'org.opencontainers.image.licenses',\n  url: 'org.opencontainers.image.url',\n  source: 'org.opencontainers.image.source',\n  documentation: 'org.opencontainers.image.documentation',\n} as const;\n"]}

package/lib/validation/index.d.ts

@@ -1,7 +1,16 @@
-export * from './common-schemas.js';
+export { VisibilitySchema, MAX_PAGE_LIMIT, DEFAULT_PAGE_LIMIT, UUIDPrefixSchema, } from './common-schemas.js';
 export * from './pipeline-schemas.js';
-export * from './pipeline-template-schemas.js';
+export { PipelineTemplateFilterSchema, PipelineTemplateCreateSchema, PipelineTemplateUpdateSchema, InstantiateTemplateSchema, } from './pipeline-template-schemas.js';
 export * from './plugin-schemas.js';
-export * from './message-schemas.js';
+export { isAllowedSpdxId, projectUrlProblem, validateCatalogField, findContractKeys, contractKeysMessage, SPDX_LICENSE_IDS, URL_SHORTENER_HOSTS, ICON_KEY_PATTERN, PluginCatalogEditsSchema, type PluginCatalogEdits, PLUGIN_CONTRACT_FIELDS, } from './plugin-catalog-metadata.js';
+export { isAllowedAttachmentType, MessageTypeSchema, MessagePrioritySchema, MessageFilterSchema, MESSAGE_ATTACHMENT_MAX_BYTES, MESSAGE_ATTACHMENT_ALLOWED_MIME, MessageCreateSchema, MessageReplySchema, MessageEditSchema, } from './message-schemas.js';
 export * from './ai-schemas.js';
-export * from './middleware.js';
+export { validate, validateQuery, validateBody, } from './middleware.js';
+export { isValidEgressHost, checkPluginSpec, checkPluginConfig, pluginSpecRequiredFieldsProblem, PLUGIN_TYPES, PLUGIN_COMPUTE_TYPES, PLUGIN_FAILURE_BEHAVIORS, PLUGIN_BUILD_TYPES, type PluginBuildType, PLUGIN_NAME_PATTERN, PLUGIN_VERSION_PATTERN, EGRESS_MAX_HOSTS, type PluginSpecInput, type PackageCheck, } from './plugin-spec-schema.js';
+export { stripInlineMarkdown, readmeTitle, readmeFirstParagraph, firstSentence, detectCatalogMetadata, resolveCatalogMetadata, acceptAllCatalogMetadata, parseCatalogEdits, parseCatalogEditsPart, type DetectedField, type CatalogSpecFields, type ResolvedCatalog, } from './plugin-catalog-detect.js';
+export { parseLabelArgs, parseDockerfile, OCI_LABELS, } from './dockerfile-static.js';
+export { isPluginTemplatableField, checkPluginTemplates, formatPluginTemplateIssue, PLUGIN_TEMPLATE_SCOPE_ROOTS, type PluginTemplateEngine, type PluginTemplateIssue, } from './plugin-template-contract.js';
+export { lintPluginDockerfile, lintPluginSpec, type PluginLintFinding } from './plugin-lint.js';
+export * from './plugin-base-images.js';
+export { shannonEntropy, scanPluginSourceHeuristics, blockingHeuristics, type HeuristicSeverity, type HeuristicFinding, type HeuristicsReport, type HeuristicsInputFile, HEURISTICS_MAX_FILE_BYTES, HEURISTICS_MAX_FINDINGS, } from './plugin-heuristics.js';
+export { findConfusableName } from './plugin-name-confusable.js';

package/lib/validation/index.js

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

package/lib/validation/message-schemas.js

@@ -1,15 +1,17 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { z } from 'zod';
+import { MESSAGE_PRIORITIES, MESSAGE_TYPES } from '../types/wire-vocabulary.js';
 import { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';
+import { envInt } from '../utils/env.js';
 /**
  * Message type schema
  */
-export const MessageTypeSchema = z.enum(['announcement', 'conversation']);
+export const MessageTypeSchema = z.enum(MESSAGE_TYPES);
 /**
  * Message priority schema
  */
-export const MessagePrioritySchema = z.enum(['normal', 'high', 'urgent']);
+export const MessagePrioritySchema = z.enum(MESSAGE_PRIORITIES);
 /**
  * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we
  * can add new channels (support, help, billing, …) without a schema
@@ -58,7 +60,7 @@ export const MESSAGE_MAX_ATTACHMENTS = 5;
  * (multer `fileSize`); kept here so the bound lives with the other message
  * limits rather than only inline in the route.
  */
-export const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);
+export const MESSAGE_ATTACHMENT_MAX_MB = envInt('MESSAGE_ATTACHMENT_MAX_MB', 10, { min: 1 });
 export const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;
 /**
  * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.
@@ -153,4 +155,4 @@ export const MessageReplySchema = z.object({
 export const MessageEditSchema = z.object({
     content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-schemas.js","sourceRoot":"","sources":["../../src/validation/message-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 { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';\n\n/**\n * Message type schema\n */\nexport const MessageTypeSchema = z.enum(['announcement', 'conversation']);\n\n/**\n * Message priority schema\n */\nexport const MessagePrioritySchema = z.enum(['normal', 'high', 'urgent']);\n\n/**\n * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we\n * can add new channels (support, help, billing, …) without a schema\n * migration. Constrained to a-z/0-9/dash/underscore for URL safety and\n * to keep filter conditions trivially indexable.\n */\nexport const MessageChannelSchema = z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/);\n\n/**\n * Message filter schema for query parameters.\n *\n * Convention for `threadId`:\n * - Omitted (undefined): no filter applied — returns messages regardless of thread.\n * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`\n *   by the route layer / query builder). The string sentinel `'root'` is the\n *   wire form, since URL query params can't carry a true `null`.\n * - A UUID: filter for messages in that specific thread.\n *\n * `isRead` is honored by `buildMessageConditions` in pipeline-data via a\n * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting\n * org (the function form, not the `?` operator, to avoid param-binding clashes).\n */\nexport const MessageFilterSchema = BaseFilterSchema.extend({\n  threadId: z.union([z.string().uuid(), z.literal('root'), z.null()]).optional(),\n  recipientOrgId: z.string().min(1).optional(),\n  messageType: MessageTypeSchema.optional(),\n  isRead: BooleanQuerySchema.optional(),\n  priority: MessagePrioritySchema.optional(),\n  channel: MessageChannelSchema.optional(),\n  // Free-text inbox search over subject/content. Bounded so a pathological term\n  // can't blow up the LIKE; the query builder escapes wildcards + ignores blanks.\n  search: z.string().trim().min(1).max(200).optional(),\n});\n\n/**\n * Upper bounds on free-text message fields. Without these an unbounded\n * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to\n * every org. `subject` matches the `varchar(500)` DB column so we reject rather\n * than silently truncate; `content` is a `text` column with no DB bound, so we\n * cap it at a sane 32 KiB at the app layer.\n */\nexport const MESSAGE_SUBJECT_MAX = 500;\nexport const MESSAGE_CONTENT_MAX = 32768;\n\n/** Max attachments linkable to a single message/reply. */\nexport const MESSAGE_MAX_ATTACHMENTS = 5;\n\n/**\n * Max attachment size (MiB) — env-overridable. The upload route enforces this\n * (multer `fileSize`); kept here so the bound lives with the other message\n * limits rather than only inline in the route.\n */\nexport const MESSAGE_ATTACHMENT_MAX_MB = Math.max(1, Number.parseInt(process.env.MESSAGE_ATTACHMENT_MAX_MB ?? '10', 10) || 10);\nexport const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;\n\n/**\n * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.\n * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).\n * zip is a download container (doesn't render in-browser); yaml/json are plain\n * text — none carry the drive-by risk of the excluded types. Extend here.\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string> = new Set([\n  'image/png', 'image/jpeg', 'image/gif', 'image/webp',\n  'application/pdf', 'text/plain', 'text/csv',\n  'application/msword',\n  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  'application/vnd.ms-excel',\n  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n  // Archives (zip / gz / tar / tar.gz) — browsers report these variously by OS;\n  // cover the common variants. They download rather than render in-browser.\n  'application/zip', 'application/x-zip-compressed',\n  'application/gzip', 'application/x-gzip',\n  'application/x-tar', 'application/tar',\n  'application/x-compressed-tar',\n  // json (browsers may send application/json or text/json).\n  'application/json', 'text/json',\n  // yaml/yml — no single registered type; cover the common variants.\n  'application/x-yaml', 'application/yaml', 'text/yaml', 'text/x-yaml',\n]);\n\n/**\n * Safe filename extensions. Browsers frequently send `application/octet-stream`\n * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no\n * reliable registered MIME type, so the MIME allow-list alone rejects them. These\n * extensions are accepted as a fallback ONLY when the reported MIME is that\n * generic type (see isAllowedAttachmentType) — so a known render/execute MIME\n * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still\n * excludes .html/.svg/.js/.exe/… (never listed here).\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_EXT: ReadonlySet<string> = new Set([\n  '.png', '.jpg', '.jpeg', '.gif', '.webp',\n  '.pdf', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',\n  '.zip', '.gz', '.tgz', '.tar', '.json', '.yaml', '.yml',\n]);\n\n/**\n * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the\n * browser reports the generic `application/octet-stream` (unknown binary) — by a\n * safe filename extension. octet-stream is served as a download (never rendered),\n * so the extension fallback can't turn into a stored-XSS vector.\n */\nexport function isAllowedAttachmentType(mimetype: string, filename: string): boolean {\n  if (MESSAGE_ATTACHMENT_ALLOWED_MIME.has(mimetype)) return true;\n  if (mimetype !== 'application/octet-stream') return false;\n  const dot = (filename || '').lastIndexOf('.');\n  if (dot < 0) return false;\n  return MESSAGE_ATTACHMENT_ALLOWED_EXT.has(filename.slice(dot).toLowerCase());\n}\n\n/** Attachment metadata DTO returned to clients (never exposes the storage key). */\nexport interface MessageAttachmentDTO {\n  id: string;\n  filename: string;\n  contentType: string;\n  sizeBytes: number;\n}\n\n/**\n * Attachment ids to link to a message. Each is the id returned by a prior\n * POST /messages/attachments upload; the create route links only ids that belong\n * to the caller (own org + uploader) and are still unattached.\n */\nconst AttachmentIdsSchema = z.array(z.string().uuid()).max(MESSAGE_MAX_ATTACHMENTS).optional();\n\n/**\n * Message creation schema\n */\nexport const MessageCreateSchema = z.object({\n  recipientOrgId: z.string().min(1, 'Recipient organization ID is required'),\n  // Optional per-user targeting WITHIN recipientOrgId. When set, only this user\n  // sees the conversation (enforced in buildMessageConditions). Conversation-only\n  // and requires a concrete recipient org — the route rejects it on announcements\n  // and '*' broadcasts. Bounded to the recipient_user_id column width.\n  recipientUserId: z.string().min(1).max(255).optional(),\n  messageType: MessageTypeSchema.optional().default('conversation'),\n  channel: MessageChannelSchema.optional(),\n  subject: z.string().min(1, 'Subject is required').max(MESSAGE_SUBJECT_MAX, `Subject must be at most ${MESSAGE_SUBJECT_MAX} characters`),\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  priority: MessagePrioritySchema.optional().default('normal'),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Message reply schema\n */\nexport const MessageReplySchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Edit an already-sent message's CONTENT (author-only, enforced server-side).\n * Only the body is editable — subject/recipient/type/attachments are immutable\n * after send (changing them would rewrite the conversation's routing/meaning).\n */\nexport const MessageEditSchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-schemas.js","sourceRoot":"","sources":["../../src/validation/message-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 { MESSAGE_PRIORITIES, MESSAGE_TYPES } from '../types/wire-vocabulary.js';\nimport { BaseFilterSchema, BooleanQuerySchema } from './common-schemas.js';\nimport { envInt } from '../utils/env.js';\n\n/**\n * Message type schema\n */\nexport const MessageTypeSchema = z.enum(MESSAGE_TYPES);\n\n/**\n * Message priority schema\n */\nexport const MessagePrioritySchema = z.enum(MESSAGE_PRIORITIES);\n\n/**\n * Channel/inbox-bucket schema. Open-ended string up to 50 chars so we\n * can add new channels (support, help, billing, …) without a schema\n * migration. Constrained to a-z/0-9/dash/underscore for URL safety and\n * to keep filter conditions trivially indexable.\n */\nexport const MessageChannelSchema = z.string().min(1).max(50).regex(/^[a-z0-9_-]+$/);\n\n/**\n * Message filter schema for query parameters.\n *\n * Convention for `threadId`:\n * - Omitted (undefined): no filter applied — returns messages regardless of thread.\n * - `'root'` or `null`: filter for root messages only (translated to `threadId IS NULL`\n *   by the route layer / query builder). The string sentinel `'root'` is the\n *   wire form, since URL query params can't carry a true `null`.\n * - A UUID: filter for messages in that specific thread.\n *\n * `isRead` is honored by `buildMessageConditions` in pipeline-data via a\n * `jsonb_exists(read_by, $orgId)` check on `messages.read_by` for the requesting\n * org (the function form, not the `?` operator, to avoid param-binding clashes).\n */\nexport const MessageFilterSchema = BaseFilterSchema.extend({\n  threadId: z.union([z.string().uuid(), z.literal('root'), z.null()]).optional(),\n  recipientOrgId: z.string().min(1).optional(),\n  messageType: MessageTypeSchema.optional(),\n  isRead: BooleanQuerySchema.optional(),\n  priority: MessagePrioritySchema.optional(),\n  channel: MessageChannelSchema.optional(),\n  // Free-text inbox search over subject/content. Bounded so a pathological term\n  // can't blow up the LIKE; the query builder escapes wildcards + ignores blanks.\n  search: z.string().trim().min(1).max(200).optional(),\n});\n\n/**\n * Upper bounds on free-text message fields. Without these an unbounded\n * subject/content (e.g. a 1MB announcement) is persisted AND SSE-broadcast to\n * every org. `subject` matches the `varchar(500)` DB column so we reject rather\n * than silently truncate; `content` is a `text` column with no DB bound, so we\n * cap it at a sane 32 KiB at the app layer.\n */\nexport const MESSAGE_SUBJECT_MAX = 500;\nexport const MESSAGE_CONTENT_MAX = 32768;\n\n/** Max attachments linkable to a single message/reply. */\nexport const MESSAGE_MAX_ATTACHMENTS = 5;\n\n/**\n * Max attachment size (MiB) — env-overridable. The upload route enforces this\n * (multer `fileSize`); kept here so the bound lives with the other message\n * limits rather than only inline in the route.\n */\nexport const MESSAGE_ATTACHMENT_MAX_MB = envInt('MESSAGE_ATTACHMENT_MAX_MB', 10, { min: 1 });\nexport const MESSAGE_ATTACHMENT_MAX_BYTES = MESSAGE_ATTACHMENT_MAX_MB * 1024 * 1024;\n\n/**\n * Allow-list of attachment MIME types — common images + documents + zip/yaml/json.\n * Deliberately excludes executables/scripts/HTML/SVG (stored-XSS / drive-by).\n * zip is a download container (doesn't render in-browser); yaml/json are plain\n * text — none carry the drive-by risk of the excluded types. Extend here.\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_MIME: ReadonlySet<string> = new Set([\n  'image/png', 'image/jpeg', 'image/gif', 'image/webp',\n  'application/pdf', 'text/plain', 'text/csv',\n  'application/msword',\n  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n  'application/vnd.ms-excel',\n  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n  // Archives (zip / gz / tar / tar.gz) — browsers report these variously by OS;\n  // cover the common variants. They download rather than render in-browser.\n  'application/zip', 'application/x-zip-compressed',\n  'application/gzip', 'application/x-gzip',\n  'application/x-tar', 'application/tar',\n  'application/x-compressed-tar',\n  // json (browsers may send application/json or text/json).\n  'application/json', 'text/json',\n  // yaml/yml — no single registered type; cover the common variants.\n  'application/x-yaml', 'application/yaml', 'text/yaml', 'text/x-yaml',\n]);\n\n/**\n * Safe filename extensions. Browsers frequently send `application/octet-stream`\n * for archives + config files (.tar/.gz/.tgz/.yaml/…) because they have no\n * reliable registered MIME type, so the MIME allow-list alone rejects them. These\n * extensions are accepted as a fallback ONLY when the reported MIME is that\n * generic type (see isAllowedAttachmentType) — so a known render/execute MIME\n * (image/svg+xml, text/html, …) is never rescued by a spoofed extension. Still\n * excludes .html/.svg/.js/.exe/… (never listed here).\n */\nexport const MESSAGE_ATTACHMENT_ALLOWED_EXT: ReadonlySet<string> = new Set([\n  '.png', '.jpg', '.jpeg', '.gif', '.webp',\n  '.pdf', '.txt', '.csv', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',\n  '.zip', '.gz', '.tgz', '.tar', '.json', '.yaml', '.yml',\n]);\n\n/**\n * True if an attachment is accepted. Accepts by MIME allow-list, OR — when the\n * browser reports the generic `application/octet-stream` (unknown binary) — by a\n * safe filename extension. octet-stream is served as a download (never rendered),\n * so the extension fallback can't turn into a stored-XSS vector.\n */\nexport function isAllowedAttachmentType(mimetype: string, filename: string): boolean {\n  if (MESSAGE_ATTACHMENT_ALLOWED_MIME.has(mimetype)) return true;\n  if (mimetype !== 'application/octet-stream') return false;\n  const dot = (filename || '').lastIndexOf('.');\n  if (dot < 0) return false;\n  return MESSAGE_ATTACHMENT_ALLOWED_EXT.has(filename.slice(dot).toLowerCase());\n}\n\n/** Attachment metadata DTO returned to clients (never exposes the storage key). */\nexport interface MessageAttachmentDTO {\n  id: string;\n  filename: string;\n  contentType: string;\n  sizeBytes: number;\n}\n\n/**\n * Attachment ids to link to a message. Each is the id returned by a prior\n * POST /messages/attachments upload; the create route links only ids that belong\n * to the caller (own org + uploader) and are still unattached.\n */\nconst AttachmentIdsSchema = z.array(z.string().uuid()).max(MESSAGE_MAX_ATTACHMENTS).optional();\n\n/**\n * Message creation schema\n */\nexport const MessageCreateSchema = z.object({\n  recipientOrgId: z.string().min(1, 'Recipient organization ID is required'),\n  // Optional per-user targeting WITHIN recipientOrgId. When set, only this user\n  // sees the conversation (enforced in buildMessageConditions). Conversation-only\n  // and requires a concrete recipient org — the route rejects it on announcements\n  // and '*' broadcasts. Bounded to the recipient_user_id column width.\n  recipientUserId: z.string().min(1).max(255).optional(),\n  messageType: MessageTypeSchema.optional().default('conversation'),\n  channel: MessageChannelSchema.optional(),\n  subject: z.string().min(1, 'Subject is required').max(MESSAGE_SUBJECT_MAX, `Subject must be at most ${MESSAGE_SUBJECT_MAX} characters`),\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  priority: MessagePrioritySchema.optional().default('normal'),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Message reply schema\n */\nexport const MessageReplySchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n  attachmentIds: AttachmentIdsSchema,\n});\n\n/**\n * Edit an already-sent message's CONTENT (author-only, enforced server-side).\n * Only the body is editable — subject/recipient/type/attachments are immutable\n * after send (changing them would rewrite the conversation's routing/meaning).\n */\nexport const MessageEditSchema = z.object({\n  content: z.string().min(1, 'Content is required').max(MESSAGE_CONTENT_MAX, `Content must be at most ${MESSAGE_CONTENT_MAX} characters`),\n});\n"]}

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

@@ -76,6 +76,7 @@ export declare const PipelineCreateSchema: z.ZodObject<{
             source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             plugin: z.ZodObject<{
                 name: z.ZodString;
+                publisher: z.ZodOptional<z.ZodString>;
                 alias: z.ZodOptional<z.ZodString>;
                 filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -84,9 +85,11 @@ export declare const PipelineCreateSchema: z.ZodObject<{
         stages: z.ZodOptional<z.ZodArray<z.ZodObject<{
             stageName: z.ZodString;
             alias: z.ZodOptional<z.ZodString>;
+            environment: z.ZodOptional<z.ZodString>;
             steps: z.ZodArray<z.ZodObject<{
                 plugin: z.ZodObject<{
                     name: z.ZodString;
+                    publisher: z.ZodOptional<z.ZodString>;
                     alias: z.ZodOptional<z.ZodString>;
                     filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -98,7 +101,7 @@ export declare const PipelineCreateSchema: z.ZodObject<{
                     pre: "pre";
                 }>>;
             }, z.core.$loose>>;
-        }, z.core.$strip>>>;
+        }, z.core.$loose>>>;
     }, z.core.$loose>;
 }, z.core.$strip>;
 /**
@@ -141,6 +144,7 @@ export declare const PipelineUpdateSchema: z.ZodObject<{
             source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             plugin: z.ZodObject<{
                 name: z.ZodString;
+                publisher: z.ZodOptional<z.ZodString>;
                 alias: z.ZodOptional<z.ZodString>;
                 filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -149,9 +153,11 @@ export declare const PipelineUpdateSchema: z.ZodObject<{
         stages: z.ZodOptional<z.ZodArray<z.ZodObject<{
             stageName: z.ZodString;
             alias: z.ZodOptional<z.ZodString>;
+            environment: z.ZodOptional<z.ZodString>;
             steps: z.ZodArray<z.ZodObject<{
                 plugin: z.ZodObject<{
                     name: z.ZodString;
+                    publisher: z.ZodOptional<z.ZodString>;
                     alias: z.ZodOptional<z.ZodString>;
                     filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -163,7 +169,7 @@ export declare const PipelineUpdateSchema: z.ZodObject<{
                     pre: "pre";
                 }>>;
             }, z.core.$loose>>;
-        }, z.core.$strip>>>;
+        }, z.core.$loose>>>;
     }, z.core.$loose>>;
     isActive: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
         false: "false";

package/lib/validation/pipeline-schemas.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { z } from 'zod';
 import { BaseFilterSchema, BooleanQuerySchema, VisibilitySchema, CatalogMetadataShape } from './common-schemas.js';
+import { PUBLISHER_HANDLE_PATTERN } from '../types/ecosystem.js';
 /**
  * Pipeline filter schema for query parameters
  */
@@ -12,15 +13,36 @@ export const PipelineFilterSchema = BaseFilterSchema.extend({
     orgId: z.string().min(1).optional(),
     keyword: z.string().min(1).optional(),
 });
+/**
+ * Keys that look like plugin-reference fields but aren't: synth never reads
+ * them, so without a loud refusal the reference silently resolves to something
+ * other than what its author meant.
+ */
+const PLUGIN_REF_NON_FIELDS = {
+    version: '`version` is not a plugin-reference field — it is ignored and the default version is used. '
+        + 'Pin or range the version with `filter: { version: "1.2.3" }` (also ^, ~, 1.x, 1.2, latest).',
+};
 /**
  * Plugin options schema (name-based selection)
  */
 const PluginOptionsSchema = z.object({
     name: z.string().min(1),
+    /**
+     * The publisher whose installed listing the reference resolves to
+     * (docs/plugin-publishing.md). Absent: the org's own plugin, then
+     * its parent's, then the Official listing.
+     */
+    publisher: z.string().max(39).regex(PUBLISHER_HANDLE_PATTERN, 'publisher must be a publisher handle (lowercase letters, digits and single hyphens)').optional(),
     alias: z.string().optional(),
     filter: z.record(z.string(), z.unknown()).optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
-}).passthrough();
+}).passthrough().superRefine((ref, ctx) => {
+    for (const [key, message] of Object.entries(PLUGIN_REF_NON_FIELDS)) {
+        if (key in ref) {
+            ctx.addIssue({ code: 'custom', path: [key], message });
+        }
+    }
+});
 /**
  * Stage step schema
  *
@@ -48,13 +70,17 @@ const StageStepSchema = z.object({
     }
 });
 /**
- * Stage schema
+ * Stage schema. `passthrough()` like its siblings: a strict-by-default object
+ * here stripped every undeclared stage field before storage — including
+ * `environment`, which marks a stage as a DORA deploy.
  */
 const StageSchema = z.object({
     stageName: z.string().min(1),
     alias: z.string().optional(),
+    /** Deploy environment this stage targets (DORA deploy attribution, `pb.deploys`). */
+    environment: z.string().min(1).max(64).optional(),
     steps: z.array(StageStepSchema).min(1),
-});
+}).passthrough();
 /**
  * BuilderProps schema — structural validation for pipeline configuration.
  * Uses passthrough() to allow additional fields without rejecting them.
@@ -98,4 +124,4 @@ export const PipelineUpdateSchema = z.object({
     isDefault: BooleanQuerySchema.optional(),
     visibility: VisibilitySchema.optional(),
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-schemas.js","sourceRoot":"","sources":["../../src/validation/pipeline-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 { BaseFilterSchema, BooleanQuerySchema, VisibilitySchema, CatalogMetadataShape } from './common-schemas.js';\n\n/**\n * Pipeline filter schema for query parameters\n */\nexport const PipelineFilterSchema = BaseFilterSchema.extend({\n  project: z.string().min(1).optional(),\n  organization: z.string().min(1).optional(),\n  pipelineName: z.string().min(1).optional(),\n  orgId: z.string().min(1).optional(),\n  keyword: z.string().min(1).optional(),\n});\n\n/**\n * Plugin options schema (name-based selection)\n */\nconst PluginOptionsSchema = z.object({\n  name: z.string().min(1),\n  alias: z.string().optional(),\n  filter: z.record(z.string(), z.unknown()).optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n}).passthrough();\n\n/**\n * Stage step schema\n *\n * `passthrough()` keeps forward-compatible fields, but a few common mistakes are\n * rejected loudly rather than silently ignored at synth — most notably a\n * top-level `commands`, which is NOT a step field (the plugin's own commands run)\n * and would otherwise do nothing.\n */\nconst STEP_NON_FIELDS: Record<string, string> = {\n  commands:\n    '`commands` is not a step field — it is ignored at synth (the plugin\\'s own commands run). '\n    + 'To change what a step runs, use a plugin env knob (e.g. `metadata.GRADLE_TASK`), '\n    + '`preCommands`/`postCommands` to add commands around the plugin\\'s, or the '\n    + '`aws:cdk:pipelines:codebuildstep:commands` metadata key for a full override.',\n};\n\nconst StageStepSchema = z.object({\n  plugin: PluginOptionsSchema,\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  network: z.record(z.string(), z.unknown()).optional(),\n  position: z.enum(['pre', 'post']).optional(),\n}).passthrough().superRefine((step, ctx) => {\n  for (const [key, message] of Object.entries(STEP_NON_FIELDS)) {\n    if (key in (step as Record<string, unknown>)) {\n      ctx.addIssue({ code: 'custom', path: [key], message });\n    }\n  }\n});\n\n/**\n * Stage schema\n */\nconst StageSchema = z.object({\n  stageName: z.string().min(1),\n  alias: z.string().optional(),\n  steps: z.array(StageStepSchema).min(1),\n});\n\n/**\n * BuilderProps schema — structural validation for pipeline configuration.\n * Uses passthrough() to allow additional fields without rejecting them.\n */\nconst BuilderPropsSchema = z.object({\n  project: z.string().min(1),\n  organization: z.string().min(1),\n  pipelineName: z.string().optional(),\n  global: z.record(z.string(), z.unknown()).optional(),\n  defaults: z.record(z.string(), z.unknown()).optional(),\n  role: z.record(z.string(), z.unknown()).optional(),\n  synth: z.object({\n    source: z.record(z.string(), z.unknown()).optional(),\n    plugin: PluginOptionsSchema,\n  }).passthrough(),\n  stages: z.array(StageSchema).optional(),\n}).passthrough();\n\n/**\n * Pipeline creation schema\n */\nexport const PipelineCreateSchema = z.object({\n  ...CatalogMetadataShape,\n  project: z.string().min(1, 'Project is required'),\n  organization: z.string().min(1, 'Organization is required'),\n  pipelineName: z.string().min(1).optional(),\n  description: z.string().optional(),\n  keywords: z.array(z.string()).optional(),\n  visibility: VisibilitySchema.optional(),\n  props: BuilderPropsSchema,\n});\n\n/**\n * Pipeline update schema\n */\nexport const PipelineUpdateSchema = z.object({\n  ...CatalogMetadataShape,\n  pipelineName: z.string().min(1).optional(),\n  description: z.string().optional(),\n  keywords: z.array(z.string()).optional(),\n  props: BuilderPropsSchema.optional(),\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  visibility: VisibilitySchema.optional(),\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-schemas.js","sourceRoot":"","sources":["../../src/validation/pipeline-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 { BaseFilterSchema, BooleanQuerySchema, VisibilitySchema, CatalogMetadataShape } from './common-schemas.js';\nimport { PUBLISHER_HANDLE_PATTERN } from '../types/ecosystem.js';\n\n/**\n * Pipeline filter schema for query parameters\n */\nexport const PipelineFilterSchema = BaseFilterSchema.extend({\n  project: z.string().min(1).optional(),\n  organization: z.string().min(1).optional(),\n  pipelineName: z.string().min(1).optional(),\n  orgId: z.string().min(1).optional(),\n  keyword: z.string().min(1).optional(),\n});\n\n/**\n * Keys that look like plugin-reference fields but aren't: synth never reads\n * them, so without a loud refusal the reference silently resolves to something\n * other than what its author meant.\n */\nconst PLUGIN_REF_NON_FIELDS: Record<string, string> = {\n  version:\n    '`version` is not a plugin-reference field — it is ignored and the default version is used. '\n    + 'Pin or range the version with `filter: { version: \"1.2.3\" }` (also ^, ~, 1.x, 1.2, latest).',\n};\n\n/**\n * Plugin options schema (name-based selection)\n */\nconst PluginOptionsSchema = z.object({\n  name: z.string().min(1),\n  /**\n   * The publisher whose installed listing the reference resolves to\n   * (docs/plugin-publishing.md). Absent: the org's own plugin, then\n   * its parent's, then the Official listing.\n   */\n  publisher: z.string().max(39).regex(PUBLISHER_HANDLE_PATTERN, 'publisher must be a publisher handle (lowercase letters, digits and single hyphens)').optional(),\n  alias: z.string().optional(),\n  filter: z.record(z.string(), z.unknown()).optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n}).passthrough().superRefine((ref, ctx) => {\n  for (const [key, message] of Object.entries(PLUGIN_REF_NON_FIELDS)) {\n    if (key in (ref as Record<string, unknown>)) {\n      ctx.addIssue({ code: 'custom', path: [key], message });\n    }\n  }\n});\n\n/**\n * Stage step schema\n *\n * `passthrough()` keeps forward-compatible fields, but a few common mistakes are\n * rejected loudly rather than silently ignored at synth — most notably a\n * top-level `commands`, which is NOT a step field (the plugin's own commands run)\n * and would otherwise do nothing.\n */\nconst STEP_NON_FIELDS: Record<string, string> = {\n  commands:\n    '`commands` is not a step field — it is ignored at synth (the plugin\\'s own commands run). '\n    + 'To change what a step runs, use a plugin env knob (e.g. `metadata.GRADLE_TASK`), '\n    + '`preCommands`/`postCommands` to add commands around the plugin\\'s, or the '\n    + '`aws:cdk:pipelines:codebuildstep:commands` metadata key for a full override.',\n};\n\nconst StageStepSchema = z.object({\n  plugin: PluginOptionsSchema,\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  network: z.record(z.string(), z.unknown()).optional(),\n  position: z.enum(['pre', 'post']).optional(),\n}).passthrough().superRefine((step, ctx) => {\n  for (const [key, message] of Object.entries(STEP_NON_FIELDS)) {\n    if (key in (step as Record<string, unknown>)) {\n      ctx.addIssue({ code: 'custom', path: [key], message });\n    }\n  }\n});\n\n/**\n * Stage schema. `passthrough()` like its siblings: a strict-by-default object\n * here stripped every undeclared stage field before storage — including\n * `environment`, which marks a stage as a DORA deploy.\n */\nconst StageSchema = z.object({\n  stageName: z.string().min(1),\n  alias: z.string().optional(),\n  /** Deploy environment this stage targets (DORA deploy attribution, `pb.deploys`). */\n  environment: z.string().min(1).max(64).optional(),\n  steps: z.array(StageStepSchema).min(1),\n}).passthrough();\n\n/**\n * BuilderProps schema — structural validation for pipeline configuration.\n * Uses passthrough() to allow additional fields without rejecting them.\n */\nconst BuilderPropsSchema = z.object({\n  project: z.string().min(1),\n  organization: z.string().min(1),\n  pipelineName: z.string().optional(),\n  global: z.record(z.string(), z.unknown()).optional(),\n  defaults: z.record(z.string(), z.unknown()).optional(),\n  role: z.record(z.string(), z.unknown()).optional(),\n  synth: z.object({\n    source: z.record(z.string(), z.unknown()).optional(),\n    plugin: PluginOptionsSchema,\n  }).passthrough(),\n  stages: z.array(StageSchema).optional(),\n}).passthrough();\n\n/**\n * Pipeline creation schema\n */\nexport const PipelineCreateSchema = z.object({\n  ...CatalogMetadataShape,\n  project: z.string().min(1, 'Project is required'),\n  organization: z.string().min(1, 'Organization is required'),\n  pipelineName: z.string().min(1).optional(),\n  description: z.string().optional(),\n  keywords: z.array(z.string()).optional(),\n  visibility: VisibilitySchema.optional(),\n  props: BuilderPropsSchema,\n});\n\n/**\n * Pipeline update schema\n */\nexport const PipelineUpdateSchema = z.object({\n  ...CatalogMetadataShape,\n  pipelineName: z.string().min(1).optional(),\n  description: z.string().optional(),\n  keywords: z.array(z.string()).optional(),\n  props: BuilderPropsSchema.optional(),\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  visibility: VisibilitySchema.optional(),\n});\n"]}

package/lib/validation/plugin-base-images.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The shared plugin base images (deploy/plugins/_base): what `plugin new`
+ * scaffolds `FROM` and what AI plugin generation tells the model to start
+ * from. Listed here because neither the CLI nor the plugin service ships the
+ * repo; a pipeline-manager test fails when the list drifts from the tree.
+ */
+/** One `pipeline-<eco>-base` image a plugin can start `FROM`. */
+export interface PluginBaseImage {
+    /** `--base` value. */
+    key: string;
+    /** Image tag the Dockerfile's `FROM` names. */
+    image: string;
+    /** Directory under deploy/plugins/_base. */
+    dir: string;
+    /** What the base provides on top of the root base. */
+    provides: string;
+    /** A command that proves the runtime is on PATH (the scaffold's smokeTest). */
+    smokeTest: string;
+}
+export declare const PLUGIN_BASE_IMAGES: readonly PluginBaseImage[];