@pipeline-builder/api-core 4.1.13 → 4.1.14

package/lib/validation/plugin-lint.js

@@ -0,0 +1,136 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The catalog's STATIC plugin checks (deploy/bin/test-plugins.sh), for a plugin
+ * directory outside the repo: the spec fields the catalog tooling requires and
+ * the Dockerfile rules (deploy/plugins/README.md "Dockerfile rules"). Shared
+ * from api-core so the CLI (`plugin validate --lint`, `plugin publish`) and the
+ * plugin service (AI generation) apply ONE implementation (plugin-ecosystem W6):
+ *
+ *  - the final stage ends as a non-root `USER`, set in the plugin's own Dockerfile;
+ *  - every download goes through `fetch-verified` (no raw curl/wget, no `ADD <url>`
+ *    without `--checksum=`);
+ *  - no pipe-to-shell installers;
+ *  - no secrets in `ENV`/`ARG`; apt caches cleaned; a `WORKDIR`;
+ *  - the spec never downloads a tool at runtime.
+ *
+ * Only the repo-layout rules (name = directory, category = parent directory)
+ * are left to test-plugins.sh: a publisher's plugin doesn't live in that tree.
+ * Warnings never fail; errors do.
+ */
+import { parseDockerfile } from './dockerfile-static.js';
+/** Spec fields test-plugins.sh requires on every plugin. */
+export const PLUGIN_LINT_REQUIRED_FIELDS = ['name', 'description', 'keywords', 'category', 'version', 'pluginType', 'computeType', 'timeout', 'failureBehavior', 'secrets'];
+/** …and on every CodeBuildStep. */
+export const PLUGIN_LINT_CODEBUILD_FIELDS = ['primaryOutputDirectory', 'dockerfile', 'installCommands', 'commands'];
+/** Logical Dockerfile instructions: comment lines dropped, `\` continuations joined. */
+export function dockerfileInstructions(content) {
+    const out = [];
+    let buf = '';
+    for (const raw of content.replace(/\r\n?/g, '\n').split('\n')) {
+        if (/^\s*#/.test(raw))
+            continue;
+        if (/\\\s*$/.test(raw)) {
+            buf += `${raw.replace(/\\\s*$/, '')} `;
+            continue;
+        }
+        buf += raw;
+        if (/\S/.test(buf))
+            out.push(buf.trim());
+        buf = '';
+    }
+    if (/\S/.test(buf))
+        out.push(buf.trim());
+    return out;
+}
+const instructionOf = (line) => (/^(\S+)/.exec(line)?.[1] ?? '').toUpperCase();
+/** RUN instructions that pipe into a shell (`curl … | bash`). */
+export function pipeInstallers(content) {
+    return dockerfileInstructions(content).filter(l => instructionOf(l) === 'RUN' && /(^|[^|])\|\s*(sudo\s+)?(\/usr)?(\/bin\/)?(ba|da|z|k)?sh(\s|$)/.test(l));
+}
+/** curl/wget DOWNLOADS in RUN, and `ADD <url>` without `--checksum=`. */
+export function rawDownloads(content) {
+    const found = [];
+    for (const line of dockerfileInstructions(content)) {
+        const instr = instructionOf(line);
+        if (instr === 'ADD' && /https?:\/\//.test(line) && !/--checksum=/.test(line)) {
+            found.push(`ADD ${line}`);
+            continue;
+        }
+        if (instr !== 'RUN')
+            continue;
+        const body = line.replace(/^\s*run\s+/i, '');
+        for (let part of body.split(/&&|\|\||;|\||\$\(|`|\(|\{/)) {
+            for (;;) {
+                part = part.replace(/^\s+/, '');
+                const prefix = /^(if|then|do|else|elif|while|until|!|sudo|exec|command|time|--[a-z-]+(=\S*)?|[A-Za-z_][A-Za-z0-9_]*=\S*)\s+/.exec(part);
+                if (!prefix)
+                    break;
+                part = part.slice(prefix[0].length);
+            }
+            if (/^(curl|wget)(\s|$)/.test(part) && (/:\/\//.test(part) || /\$/.test(part) || /\s(-o|-O|--output|--output-document)([\s=]|$)/.test(part))) {
+                found.push(part.trim());
+            }
+        }
+    }
+    return found;
+}
+/** Lint a Dockerfile against the catalog's rules. */
+export function lintPluginDockerfile(content) {
+    const findings = [];
+    const err = (message) => findings.push({ level: 'error', message });
+    const instructions = dockerfileInstructions(content);
+    if (!instructions.some(l => instructionOf(l) === 'FROM')) {
+        err('Dockerfile: missing FROM instruction');
+        return findings;
+    }
+    if (!instructions.some(l => instructionOf(l) === 'WORKDIR'))
+        err('Dockerfile: missing WORKDIR instruction');
+    if (/^(ENV|ARG)\s+(.*TOKEN|.*SECRET|.*PASSWORD|.*API_KEY|.*PRIVATE_KEY)/m.test(content)) {
+        err('Dockerfile: potential secret in an ENV/ARG instruction (pass secrets at run time via the spec\'s `secrets`)');
+    }
+    const finalUser = parseDockerfile(content).finalUser;
+    const userPart = (finalUser ?? '').split(':')[0];
+    if (!finalUser)
+        err('Dockerfile: the final stage sets no USER (end with `USER 1000:1000`)');
+    else if (userPart === 'root' || userPart === '0')
+        err(`Dockerfile: the final stage runs as root (USER ${finalUser}); end with \`USER 1000:1000\``);
+    const pipes = pipeInstallers(content);
+    if (pipes.length)
+        err(`Dockerfile: pipes a download into a shell (use a pinned release via fetch-verified, a fetch-apt-key apt repo, or an ecosystem base): ${pipes[0].slice(0, 160)}`);
+    const downloads = rawDownloads(content);
+    if (downloads.length)
+        err(`Dockerfile: raw download not via fetch-verified: ${downloads[0].slice(0, 160)}`);
+    if (/apt-get install/.test(content) && !/rm -rf \/var\/lib\/apt\/lists/.test(content)) {
+        err('Dockerfile: missing apt cache cleanup (rm -rf /var/lib/apt/lists/*)');
+    }
+    return findings;
+}
+/** Lint the spec document (as parsed) the way test-plugins.sh does. */
+export function lintPluginSpec(spec, specText) {
+    const findings = [];
+    const err = (message) => findings.push({ level: 'error', message });
+    for (const f of PLUGIN_LINT_REQUIRED_FIELDS)
+        if (!(f in spec))
+            err(`plugin-spec.yaml: missing required field: ${f}`);
+    if (spec.pluginType === 'CodeBuildStep' || spec.pluginType === undefined) {
+        for (const f of PLUGIN_LINT_CODEBUILD_FIELDS)
+            if (!(f in spec))
+                err(`plugin-spec.yaml: missing CodeBuild field: ${f}`);
+    }
+    if (typeof spec.version === 'string' && !/^\d+\.\d+\.\d+$/.test(spec.version)) {
+        err(`plugin-spec.yaml: catalog versions are plain semver x.y.z (got ${spec.version})`);
+    }
+    if (typeof spec.description !== 'string' || spec.description.trim() === '')
+        err('plugin-spec.yaml: empty description');
+    if ('keywords' in spec && (!Array.isArray(spec.keywords) || spec.keywords.length === 0))
+        err('plugin-spec.yaml: empty keywords list');
+    const download = /(curl|wget)\s.*https?:\/\/[^\s"]*(releases\/download\/|\.tar\.gz|\.tgz|\.tar\.xz|\.zip)/.exec(specText);
+    if (download)
+        err(`plugin-spec.yaml: downloads a tool at runtime (bake it into the image via fetch-verified): ${download[0].slice(0, 160)}`);
+    if (/^\s*- \|/m.test(specText) && !/set -e/.test(specText)) {
+        findings.push({ level: 'warning', message: 'plugin-spec.yaml: multi-line command(s) without `set -e` — intermediate failures will silently pass' });
+    }
+    return findings;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-lint.js","sourceRoot":"","sources":["../../src/validation/plugin-lint.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The catalog's STATIC plugin checks (deploy/bin/test-plugins.sh), for a plugin\n * directory outside the repo: the spec fields the catalog tooling requires and\n * the Dockerfile rules (deploy/plugins/README.md \"Dockerfile rules\"). Shared\n * from api-core so the CLI (`plugin validate --lint`, `plugin publish`) and the\n * plugin service (AI generation) apply ONE implementation (plugin-ecosystem W6):\n *\n *  - the final stage ends as a non-root `USER`, set in the plugin's own Dockerfile;\n *  - every download goes through `fetch-verified` (no raw curl/wget, no `ADD <url>`\n *    without `--checksum=`);\n *  - no pipe-to-shell installers;\n *  - no secrets in `ENV`/`ARG`; apt caches cleaned; a `WORKDIR`;\n *  - the spec never downloads a tool at runtime.\n *\n * Only the repo-layout rules (name = directory, category = parent directory)\n * are left to test-plugins.sh: a publisher's plugin doesn't live in that tree.\n * Warnings never fail; errors do.\n */\n\nimport { parseDockerfile } from './dockerfile-static.js';\n\nexport interface PluginLintFinding {\n  level: 'error' | 'warning';\n  message: string;\n}\n\n/** Spec fields test-plugins.sh requires on every plugin. */\nexport const PLUGIN_LINT_REQUIRED_FIELDS: readonly string[] = ['name', 'description', 'keywords', 'category', 'version', 'pluginType', 'computeType', 'timeout', 'failureBehavior', 'secrets'];\n/** …and on every CodeBuildStep. */\nexport const PLUGIN_LINT_CODEBUILD_FIELDS: readonly string[] = ['primaryOutputDirectory', 'dockerfile', 'installCommands', 'commands'];\n\n/** Logical Dockerfile instructions: comment lines dropped, `\\` continuations joined. */\nexport function dockerfileInstructions(content: string): string[] {\n  const out: string[] = [];\n  let buf = '';\n  for (const raw of content.replace(/\\r\\n?/g, '\\n').split('\\n')) {\n    if (/^\\s*#/.test(raw)) continue;\n    if (/\\\\\\s*$/.test(raw)) {\n      buf += `${raw.replace(/\\\\\\s*$/, '')} `;\n      continue;\n    }\n    buf += raw;\n    if (/\\S/.test(buf)) out.push(buf.trim());\n    buf = '';\n  }\n  if (/\\S/.test(buf)) out.push(buf.trim());\n  return out;\n}\n\nconst instructionOf = (line: string): string => (/^(\\S+)/.exec(line)?.[1] ?? '').toUpperCase();\n\n/** RUN instructions that pipe into a shell (`curl … | bash`). */\nexport function pipeInstallers(content: string): string[] {\n  return dockerfileInstructions(content).filter(l =>\n    instructionOf(l) === 'RUN' && /(^|[^|])\\|\\s*(sudo\\s+)?(\\/usr)?(\\/bin\\/)?(ba|da|z|k)?sh(\\s|$)/.test(l));\n}\n\n/** curl/wget DOWNLOADS in RUN, and `ADD <url>` without `--checksum=`. */\nexport function rawDownloads(content: string): string[] {\n  const found: string[] = [];\n  for (const line of dockerfileInstructions(content)) {\n    const instr = instructionOf(line);\n    if (instr === 'ADD' && /https?:\\/\\//.test(line) && !/--checksum=/.test(line)) {\n      found.push(`ADD ${line}`);\n      continue;\n    }\n    if (instr !== 'RUN') continue;\n    const body = line.replace(/^\\s*run\\s+/i, '');\n    for (let part of body.split(/&&|\\|\\||;|\\||\\$\\(|`|\\(|\\{/)) {\n      for (;;) {\n        part = part.replace(/^\\s+/, '');\n        const prefix = /^(if|then|do|else|elif|while|until|!|sudo|exec|command|time|--[a-z-]+(=\\S*)?|[A-Za-z_][A-Za-z0-9_]*=\\S*)\\s+/.exec(part);\n        if (!prefix) break;\n        part = part.slice(prefix[0].length);\n      }\n      if (/^(curl|wget)(\\s|$)/.test(part) && (/:\\/\\//.test(part) || /\\$/.test(part) || /\\s(-o|-O|--output|--output-document)([\\s=]|$)/.test(part))) {\n        found.push(part.trim());\n      }\n    }\n  }\n  return found;\n}\n\n/** Lint a Dockerfile against the catalog's rules. */\nexport function lintPluginDockerfile(content: string): PluginLintFinding[] {\n  const findings: PluginLintFinding[] = [];\n  const err = (message: string) => findings.push({ level: 'error', message });\n  const instructions = dockerfileInstructions(content);\n  if (!instructions.some(l => instructionOf(l) === 'FROM')) {\n    err('Dockerfile: missing FROM instruction');\n    return findings;\n  }\n  if (!instructions.some(l => instructionOf(l) === 'WORKDIR')) err('Dockerfile: missing WORKDIR instruction');\n  if (/^(ENV|ARG)\\s+(.*TOKEN|.*SECRET|.*PASSWORD|.*API_KEY|.*PRIVATE_KEY)/m.test(content)) {\n    err('Dockerfile: potential secret in an ENV/ARG instruction (pass secrets at run time via the spec\\'s `secrets`)');\n  }\n  const finalUser = parseDockerfile(content).finalUser;\n  const userPart = (finalUser ?? '').split(':')[0];\n  if (!finalUser) err('Dockerfile: the final stage sets no USER (end with `USER 1000:1000`)');\n  else if (userPart === 'root' || userPart === '0') err(`Dockerfile: the final stage runs as root (USER ${finalUser}); end with \\`USER 1000:1000\\``);\n  const pipes = pipeInstallers(content);\n  if (pipes.length) err(`Dockerfile: pipes a download into a shell (use a pinned release via fetch-verified, a fetch-apt-key apt repo, or an ecosystem base): ${pipes[0]!.slice(0, 160)}`);\n  const downloads = rawDownloads(content);\n  if (downloads.length) err(`Dockerfile: raw download not via fetch-verified: ${downloads[0]!.slice(0, 160)}`);\n  if (/apt-get install/.test(content) && !/rm -rf \\/var\\/lib\\/apt\\/lists/.test(content)) {\n    err('Dockerfile: missing apt cache cleanup (rm -rf /var/lib/apt/lists/*)');\n  }\n  return findings;\n}\n\n/** Lint the spec document (as parsed) the way test-plugins.sh does. */\nexport function lintPluginSpec(spec: Record<string, unknown>, specText: string): PluginLintFinding[] {\n  const findings: PluginLintFinding[] = [];\n  const err = (message: string) => findings.push({ level: 'error', message });\n  for (const f of PLUGIN_LINT_REQUIRED_FIELDS) if (!(f in spec)) err(`plugin-spec.yaml: missing required field: ${f}`);\n  if (spec.pluginType === 'CodeBuildStep' || spec.pluginType === undefined) {\n    for (const f of PLUGIN_LINT_CODEBUILD_FIELDS) if (!(f in spec)) err(`plugin-spec.yaml: missing CodeBuild field: ${f}`);\n  }\n  if (typeof spec.version === 'string' && !/^\\d+\\.\\d+\\.\\d+$/.test(spec.version)) {\n    err(`plugin-spec.yaml: catalog versions are plain semver x.y.z (got ${spec.version})`);\n  }\n  if (typeof spec.description !== 'string' || spec.description.trim() === '') err('plugin-spec.yaml: empty description');\n  if ('keywords' in spec && (!Array.isArray(spec.keywords) || spec.keywords.length === 0)) err('plugin-spec.yaml: empty keywords list');\n  const download = /(curl|wget)\\s.*https?:\\/\\/[^\\s\"]*(releases\\/download\\/|\\.tar\\.gz|\\.tgz|\\.tar\\.xz|\\.zip)/.exec(specText);\n  if (download) err(`plugin-spec.yaml: downloads a tool at runtime (bake it into the image via fetch-verified): ${download[0].slice(0, 160)}`);\n  if (/^\\s*- \\|/m.test(specText) && !/set -e/.test(specText)) {\n    findings.push({ level: 'warning', message: 'plugin-spec.yaml: multi-line command(s) without `set -e` — intermediate failures will silently pass' });\n  }\n  return findings;\n}\n"]}

package/lib/validation/plugin-name-confusable.d.ts

@@ -0,0 +1,15 @@
+/** The comparison form of a plugin name. */
+export declare function normalizeConfusableName(name: string): string;
+/**
+ * Optimal-string-alignment Damerau–Levenshtein distance between `a` and `b`,
+ * giving up (returning `limit + 1`) once it must exceed `limit`.
+ */
+export declare function damerauLevenshtein(a: string, b: string, limit?: number): number;
+/**
+ * The first of `names` that `candidate` is confusable with (see the module
+ * note), or null. An EXACT match counts too — the caller decides whether the
+ * same name is a conflict or the same listing.
+ */
+export declare function findConfusableName(candidate: string, names: Iterable<string>): string | null;
+/** Whether `candidate` is confusable with any of `names`. */
+export declare function isConfusableName(candidate: string, names: Iterable<string>): boolean;

package/lib/validation/plugin-name-confusable.js

@@ -0,0 +1,81 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Confusable plugin names (docs/plugin-publishing.md):
+ * a new community listing — an anonymous submission or a `new_listing`
+ * request — may not look like one of the directory's most-installed plugins
+ * (`terraf0rm`, `kube-ctl`, `docker_build`, `tfsec` → `tfsed`).
+ *
+ * Two names are CONFUSABLE when, after {@link normalizeConfusableName}
+ * (lowercase; strip `-`, `_`, `.`; `rn`→`m`, `vv`→`w`, `0`→`o`, `1`→`l`,
+ * `3`→`e`, `5`→`s`), they are equal or one Damerau–Levenshtein edit apart
+ * (an insertion, deletion, substitution or adjacent transposition).
+ *
+ * Pure, so the CLI can warn before a publish and the plugin service decides
+ * with the same rule.
+ */
+const MULTI_CHAR = [[/rn/g, 'm'], [/vv/g, 'w']];
+const SINGLE_CHAR = { 0: 'o', 1: 'l', 3: 'e', 5: 's' };
+/** The comparison form of a plugin name. */
+export function normalizeConfusableName(name) {
+    let out = name.toLowerCase().replace(/[-_.]/g, '');
+    for (const [from, to] of MULTI_CHAR)
+        out = out.replace(from, to);
+    return out.replace(/[0135]/g, (c) => SINGLE_CHAR[c] ?? c);
+}
+/**
+ * Optimal-string-alignment Damerau–Levenshtein distance between `a` and `b`,
+ * giving up (returning `limit + 1`) once it must exceed `limit`.
+ */
+export function damerauLevenshtein(a, b, limit = Number.POSITIVE_INFINITY) {
+    if (a === b)
+        return 0;
+    if (Math.abs(a.length - b.length) > limit)
+        return limit + 1;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    let prevPrev = [];
+    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const cur = [i];
+        let rowMin = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            let d = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+                d = Math.min(d, prevPrev[j - 2] + 1);
+            cur.push(d);
+            rowMin = Math.min(rowMin, d);
+        }
+        if (rowMin > limit)
+            return limit + 1;
+        prevPrev = prev;
+        prev = cur;
+    }
+    return prev[b.length];
+}
+/**
+ * The first of `names` that `candidate` is confusable with (see the module
+ * note), or null. An EXACT match counts too — the caller decides whether the
+ * same name is a conflict or the same listing.
+ */
+export function findConfusableName(candidate, names) {
+    const c = normalizeConfusableName(candidate);
+    if (c.length === 0)
+        return null;
+    for (const name of names) {
+        const n = normalizeConfusableName(name);
+        if (n.length === 0)
+            continue;
+        if (c === n || damerauLevenshtein(c, n, 1) <= 1)
+            return name;
+    }
+    return null;
+}
+/** Whether `candidate` is confusable with any of `names`. */
+export function isConfusableName(candidate, names) {
+    return findConfusableName(candidate, names) !== null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-name-confusable.js","sourceRoot":"","sources":["../../src/validation/plugin-name-confusable.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Confusable plugin names (docs/plugin-publishing.md):\n * a new community listing — an anonymous submission or a `new_listing`\n * request — may not look like one of the directory's most-installed plugins\n * (`terraf0rm`, `kube-ctl`, `docker_build`, `tfsec` → `tfsed`).\n *\n * Two names are CONFUSABLE when, after {@link normalizeConfusableName}\n * (lowercase; strip `-`, `_`, `.`; `rn`→`m`, `vv`→`w`, `0`→`o`, `1`→`l`,\n * `3`→`e`, `5`→`s`), they are equal or one Damerau–Levenshtein edit apart\n * (an insertion, deletion, substitution or adjacent transposition).\n *\n * Pure, so the CLI can warn before a publish and the plugin service decides\n * with the same rule.\n */\n\nconst MULTI_CHAR: ReadonlyArray<[RegExp, string]> = [[/rn/g, 'm'], [/vv/g, 'w']];\nconst SINGLE_CHAR: Readonly<Record<string, string>> = { 0: 'o', 1: 'l', 3: 'e', 5: 's' };\n\n/** The comparison form of a plugin name. */\nexport function normalizeConfusableName(name: string): string {\n  let out = name.toLowerCase().replace(/[-_.]/g, '');\n  for (const [from, to] of MULTI_CHAR) out = out.replace(from, to);\n  return out.replace(/[0135]/g, (c) => SINGLE_CHAR[c] ?? c);\n}\n\n/**\n * Optimal-string-alignment Damerau–Levenshtein distance between `a` and `b`,\n * giving up (returning `limit + 1`) once it must exceed `limit`.\n */\nexport function damerauLevenshtein(a: string, b: string, limit = Number.POSITIVE_INFINITY): number {\n  if (a === b) return 0;\n  if (Math.abs(a.length - b.length) > limit) return limit + 1;\n  if (a.length === 0) return b.length;\n  if (b.length === 0) return a.length;\n  let prevPrev: number[] = [];\n  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);\n  for (let i = 1; i <= a.length; i++) {\n    const cur = [i];\n    let rowMin = i;\n    for (let j = 1; j <= b.length; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      let d = Math.min(prev[j]! + 1, cur[j - 1]! + 1, prev[j - 1]! + cost);\n      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d = Math.min(d, prevPrev[j - 2]! + 1);\n      cur.push(d);\n      rowMin = Math.min(rowMin, d);\n    }\n    if (rowMin > limit) return limit + 1;\n    prevPrev = prev;\n    prev = cur;\n  }\n  return prev[b.length]!;\n}\n\n/**\n * The first of `names` that `candidate` is confusable with (see the module\n * note), or null. An EXACT match counts too — the caller decides whether the\n * same name is a conflict or the same listing.\n */\nexport function findConfusableName(candidate: string, names: Iterable<string>): string | null {\n  const c = normalizeConfusableName(candidate);\n  if (c.length === 0) return null;\n  for (const name of names) {\n    const n = normalizeConfusableName(name);\n    if (n.length === 0) continue;\n    if (c === n || damerauLevenshtein(c, n, 1) <= 1) return name;\n  }\n  return null;\n}\n\n/** Whether `candidate` is confusable with any of `names`. */\nexport function isConfusableName(candidate: string, names: Iterable<string>): boolean {\n  return findConfusableName(candidate, names) !== null;\n}\n"]}

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

@@ -24,6 +24,7 @@ export declare const PluginFilterSchema: z.ZodObject<{
         production: "production";
     }>>;
     name: z.ZodOptional<z.ZodString>;
+    publisher: z.ZodOptional<z.ZodString>;
     version: z.ZodOptional<z.ZodString>;
     orgId: z.ZodOptional<z.ZodString>;
     pluginType: z.ZodOptional<z.ZodString>;
@@ -96,7 +97,13 @@ export declare const PluginCreateSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /**
- * Plugin update schema
+ * Plugin update schema (`PUT /plugins/:id`).
+ *
+ * DESCRIPTIVE catalog fields only plus the version's operational
+ * flags and developer-portal metadata. Execution-contract keys (commands, env,
+ * secrets, compute type, …) are never accepted — the route refuses them with a
+ * 400 naming the keys before this schema runs, and `.strict()` refuses anything
+ * else unknown rather than silently dropping it.
  */
 export declare const PluginUpdateSchema: z.ZodObject<{
     ownerId: z.ZodOptional<z.ZodString>;
@@ -121,19 +128,6 @@ export declare const PluginUpdateSchema: z.ZodObject<{
         url: z.ZodString;
         icon: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    category: z.ZodOptional<z.ZodString>;
-    version: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    pluginType: z.ZodOptional<z.ZodString>;
-    computeType: z.ZodOptional<z.ZodString>;
-    primaryOutputDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    buildArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    installCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
     isActive: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
         false: "false";
         true: "true";
@@ -147,18 +141,33 @@ export declare const PluginUpdateSchema: z.ZodObject<{
         private: "private";
         public: "public";
     }>>;
-    timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    failureBehavior: z.ZodOptional<z.ZodEnum<{
-        fail: "fail";
-        ignore: "ignore";
-        warn: "warn";
-    }>>;
-    secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        required: z.ZodBoolean;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+    category: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        ai: "ai";
+        artifact: "artifact";
+        deploy: "deploy";
+        infrastructure: "infrastructure";
+        language: "language";
+        monitoring: "monitoring";
+        notification: "notification";
+        quality: "quality";
+        security: "security";
+        testing: "testing";
+    }>>>;
+    changelog: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    documentationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    homepageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    icon: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodObject<{
+        key: z.ZodString;
+        badge: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>>;
+    keywords: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    license: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    readme: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sourceUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
 /**
  * Plugin upload body schema (multipart form-data text fields)
  */
@@ -168,4 +177,9 @@ export declare const PluginUploadBodySchema: z.ZodObject<{
         private: "private";
         public: "public";
     }>>;
+    metadata: z.ZodOptional<z.ZodString>;
+    publishRequest: z.ZodOptional<z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>>;
 }, z.core.$strip>;

package/lib/validation/plugin-schemas.js

@@ -2,11 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 import { z } from 'zod';
 import { BaseFilterSchema, BooleanQuerySchema, VisibilitySchema, CatalogMetadataShape } from './common-schemas.js';
+import { PluginCatalogEditsSchema } from './plugin-catalog-metadata.js';
+import { PUBLISHER_HANDLE_PATTERN } from '../types/ecosystem.js';
 /**
  * Plugin filter schema for query parameters
  */
 export const PluginFilterSchema = BaseFilterSchema.extend({
     name: z.string().min(1).optional(),
+    /** Resolve through this publisher's installed listing; lookup only. */
+    publisher: z.string().max(39).regex(PUBLISHER_HANDLE_PATTERN).optional(),
     version: z.string().min(1).optional(),
     orgId: z.string().min(1).optional(),
     pluginType: z.string().optional(),
@@ -44,38 +48,37 @@ export const PluginCreateSchema = z.object({
     })).optional(),
 });
 /**
- * Plugin update schema
+ * Plugin update schema (`PUT /plugins/:id`).
+ *
+ * DESCRIPTIVE catalog fields only plus the version's operational
+ * flags and developer-portal metadata. Execution-contract keys (commands, env,
+ * secrets, compute type, …) are never accepted — the route refuses them with a
+ * 400 naming the keys before this schema runs, and `.strict()` refuses anything
+ * else unknown rather than silently dropping it.
  */
 export const PluginUpdateSchema = z.object({
     ...CatalogMetadataShape,
-    name: z.string().min(1).optional(),
-    description: z.string().optional(),
-    keywords: z.array(z.string()).optional(),
-    category: z.string().min(1).optional(),
-    version: z.string().min(1).optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    pluginType: z.string().optional(),
-    computeType: z.string().optional(),
-    primaryOutputDirectory: z.string().nullable().optional(),
-    env: z.record(z.string(), z.string()).optional(),
-    buildArgs: z.record(z.string(), z.string()).optional(),
-    installCommands: z.array(z.string()).optional(),
-    commands: z.array(z.string()).optional(),
+    ...PluginCatalogEditsSchema.shape,
     isActive: BooleanQuerySchema.optional(),
     isDefault: BooleanQuerySchema.optional(),
     visibility: VisibilitySchema.optional(),
-    timeout: z.number().int().positive().nullable().optional(),
-    failureBehavior: z.enum(['fail', 'warn', 'ignore']).optional(),
-    secrets: z.array(z.object({
-        name: z.string().min(1),
-        required: z.boolean(),
-        description: z.string().optional(),
-    })).optional(),
-});
+}).strict();
 /**
  * Plugin upload body schema (multipart form-data text fields)
  */
 export const PluginUploadBodySchema = z.object({
     visibility: VisibilitySchema.optional(),
+    /**
+     * Catalog metadata edits as a JSON object (a {@link PluginCatalogEditsSchema}
+     * document). Absent ⇒ every value detected from the package is accepted.
+     */
+    metadata: z.string().max(256 * 1024).optional(),
+    /**
+     * `true`: once the build completes, submit a publish request (new listing, or
+     * new version of the org's existing listing) for the built version as the
+     * uploader (docs/plugin-publishing.md). Needs `plugins:publish` and
+     * `visibility=public`. The Official catalog loader always sets it.
+     */
+    publishRequest: z.enum(['true', 'false']).optional(),
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-schemas.js","sourceRoot":"","sources":["../../src/validation/plugin-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 * Plugin filter schema for query parameters\n */\nexport const PluginFilterSchema = BaseFilterSchema.extend({\n  name: z.string().min(1).optional(),\n  version: z.string().min(1).optional(),\n  orgId: z.string().min(1).optional(),\n  pluginType: z.string().optional(),\n  keyword: z.string().min(1).optional(),\n  category: z.string().min(1).optional(),\n});\n\n/**\n * Plugin creation schema — used for OpenAPI documentation and direct API creation.\n * Currently no route uses this directly; plugins are created via upload or AI generation.\n * Retained for future direct-create endpoint and OpenAPI spec completeness.\n */\nexport const PluginCreateSchema = z.object({\n  ...CatalogMetadataShape,\n  orgId: z.string().min(1, 'Organization ID is required'),\n  name: z.string().min(1, 'Plugin name is required'),\n  version: z.string().min(1, 'Version is required'),\n  visibility: VisibilitySchema.optional(),\n  category: z.string().min(1).optional(),\n  pluginType: z.string().optional(),\n  computeType: z.string().optional(),\n  primaryOutputDirectory: z.string().nullable().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  buildArgs: z.record(z.string(), z.string()).optional(),\n  installCommands: z.array(z.string()).optional(),\n  commands: z.array(z.string()).optional(),\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  timeout: z.number().int().positive().nullable().optional(),\n  failureBehavior: z.enum(['fail', 'warn', 'ignore']).optional(),\n  secrets: z.array(z.object({\n    name: z.string().min(1),\n    required: z.boolean(),\n    description: z.string().optional(),\n  })).optional(),\n});\n\n/**\n * Plugin update schema\n */\nexport const PluginUpdateSchema = z.object({\n  ...CatalogMetadataShape,\n  name: z.string().min(1).optional(),\n  description: z.string().optional(),\n  keywords: z.array(z.string()).optional(),\n  category: z.string().min(1).optional(),\n  version: z.string().min(1).optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  pluginType: z.string().optional(),\n  computeType: z.string().optional(),\n  primaryOutputDirectory: z.string().nullable().optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  buildArgs: z.record(z.string(), z.string()).optional(),\n  installCommands: z.array(z.string()).optional(),\n  commands: z.array(z.string()).optional(),\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  visibility: VisibilitySchema.optional(),\n  timeout: z.number().int().positive().nullable().optional(),\n  failureBehavior: z.enum(['fail', 'warn', 'ignore']).optional(),\n  secrets: z.array(z.object({\n    name: z.string().min(1),\n    required: z.boolean(),\n    description: z.string().optional(),\n  })).optional(),\n});\n\n/**\n * Plugin upload body schema (multipart form-data text fields)\n */\nexport const PluginUploadBodySchema = z.object({\n  visibility: VisibilitySchema.optional(),\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-schemas.js","sourceRoot":"","sources":["../../src/validation/plugin-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 { PluginCatalogEditsSchema } from './plugin-catalog-metadata.js';\nimport { PUBLISHER_HANDLE_PATTERN } from '../types/ecosystem.js';\n\n/**\n * Plugin filter schema for query parameters\n */\nexport const PluginFilterSchema = BaseFilterSchema.extend({\n  name: z.string().min(1).optional(),\n  /** Resolve through this publisher's installed listing; lookup only. */\n  publisher: z.string().max(39).regex(PUBLISHER_HANDLE_PATTERN).optional(),\n  version: z.string().min(1).optional(),\n  orgId: z.string().min(1).optional(),\n  pluginType: z.string().optional(),\n  keyword: z.string().min(1).optional(),\n  category: z.string().min(1).optional(),\n});\n\n/**\n * Plugin creation schema — used for OpenAPI documentation and direct API creation.\n * Currently no route uses this directly; plugins are created via upload or AI generation.\n * Retained for future direct-create endpoint and OpenAPI spec completeness.\n */\nexport const PluginCreateSchema = z.object({\n  ...CatalogMetadataShape,\n  orgId: z.string().min(1, 'Organization ID is required'),\n  name: z.string().min(1, 'Plugin name is required'),\n  version: z.string().min(1, 'Version is required'),\n  visibility: VisibilitySchema.optional(),\n  category: z.string().min(1).optional(),\n  pluginType: z.string().optional(),\n  computeType: z.string().optional(),\n  primaryOutputDirectory: z.string().nullable().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  buildArgs: z.record(z.string(), z.string()).optional(),\n  installCommands: z.array(z.string()).optional(),\n  commands: z.array(z.string()).optional(),\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  timeout: z.number().int().positive().nullable().optional(),\n  failureBehavior: z.enum(['fail', 'warn', 'ignore']).optional(),\n  secrets: z.array(z.object({\n    name: z.string().min(1),\n    required: z.boolean(),\n    description: z.string().optional(),\n  })).optional(),\n});\n\n/**\n * Plugin update schema (`PUT /plugins/:id`).\n *\n * DESCRIPTIVE catalog fields only plus the version's operational\n * flags and developer-portal metadata. Execution-contract keys (commands, env,\n * secrets, compute type, …) are never accepted — the route refuses them with a\n * 400 naming the keys before this schema runs, and `.strict()` refuses anything\n * else unknown rather than silently dropping it.\n */\nexport const PluginUpdateSchema = z.object({\n  ...CatalogMetadataShape,\n  ...PluginCatalogEditsSchema.shape,\n  isActive: BooleanQuerySchema.optional(),\n  isDefault: BooleanQuerySchema.optional(),\n  visibility: VisibilitySchema.optional(),\n}).strict();\n\n/**\n * Plugin upload body schema (multipart form-data text fields)\n */\nexport const PluginUploadBodySchema = z.object({\n  visibility: VisibilitySchema.optional(),\n  /**\n   * Catalog metadata edits as a JSON object (a {@link PluginCatalogEditsSchema}\n   * document). Absent ⇒ every value detected from the package is accepted.\n   */\n  metadata: z.string().max(256 * 1024).optional(),\n  /**\n   * `true`: once the build completes, submit a publish request (new listing, or\n   * new version of the org's existing listing) for the built version as the\n   * uploader (docs/plugin-publishing.md). Needs `plugins:publish` and\n   * `visibility=public`. The Official catalog loader always sets it.\n   */\n  publishRequest: z.enum(['true', 'false']).optional(),\n});\n"]}

package/lib/validation/plugin-spec-schema.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The plugin PACKAGE schemas: `plugin-spec.yaml` and `config.yaml`, exactly as
+ * the plugin service validates an upload. Shared from api-core so the upload
+ * path (api/plugin) and the CLI (`pipeline-manager plugin validate` /
+ * `plugin publish`) apply ONE schema and can't drift.
+ *
+ * Pure: no YAML parsing, no filesystem. Callers parse (with their own size and
+ * alias bounds) and hand the resulting object to {@link checkPluginSpec} /
+ * {@link checkPluginConfig}.
+ */
+import { z } from 'zod';
+export declare const PLUGIN_TYPES: readonly ['CodeBuildStep', 'ShellStep', 'ManualApprovalStep'];
+export declare const PLUGIN_COMPUTE_TYPES: readonly ['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE'];
+export declare const PLUGIN_FAILURE_BEHAVIORS: readonly ['fail', 'warn', 'ignore'];
+export declare const PLUGIN_BUILD_TYPES: readonly ['build_image', 'prebuilt', 'metadata_only'];
+export type PluginBuildType = typeof PLUGIN_BUILD_TYPES[number];
+/** Plugin name: lowercase letters, digits and hyphens. */
+export declare const PLUGIN_NAME_PATTERN: RegExp;
+/** Plugin version: semver, with optional `-prerelease` and `+build` metadata. */
+export declare const PLUGIN_VERSION_PATTERN: RegExp;
+/** Max declared `network.egress` hostnames. */
+export declare const EGRESS_MAX_HOSTS = 50;
+/** True when `host` is an acceptable `network.egress` entry. */
+export declare function isValidEgressHost(host: string): boolean;
+export declare const PluginConfigSchema: z.ZodObject<{
+    pluginSpec: z.ZodOptional<z.ZodString>;
+    dockerfile: z.ZodOptional<z.ZodString>;
+    buildType: z.ZodOptional<z.ZodEnum<{
+        build_image: "build_image";
+        metadata_only: "metadata_only";
+        prebuilt: "prebuilt";
+    }>>;
+    imageTag: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PluginConfigInput = z.infer<typeof PluginConfigSchema>;
+export declare const PluginSpecSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    category: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    pluginType: z.ZodOptional<z.ZodEnum<{
+        CodeBuildStep: "CodeBuildStep";
+        ManualApprovalStep: "ManualApprovalStep";
+        ShellStep: "ShellStep";
+    }>>;
+    computeType: z.ZodOptional<z.ZodEnum<{
+        LARGE: "LARGE";
+        MEDIUM: "MEDIUM";
+        SMALL: "SMALL";
+        X2_LARGE: "X2_LARGE";
+    }>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    failureBehavior: z.ZodOptional<z.ZodEnum<{
+        fail: "fail";
+        ignore: "ignore";
+        warn: "warn";
+    }>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    primaryOutputDirectory: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | undefined, string | null | undefined>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    dockerfile: z.ZodOptional<z.ZodString>;
+    installCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    buildArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    requiredMetadata: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    requiredVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadataTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    varsTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    smokeTest: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    changelog: z.ZodOptional<z.ZodString>;
+    homepageUrl: z.ZodOptional<z.ZodString>;
+    sourceUrl: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    documentationUrl: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        key: z.ZodString;
+        badge: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    network: z.ZodOptional<z.ZodObject<{
+        egress: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PluginSpecInput = z.infer<typeof PluginSpecSchema>;
+/**
+ * Result of checking a parsed YAML document against a package schema:
+ * `issues` are the individual problems, `message` the one-line form the upload
+ * API reports (`plugin-spec.yaml: <path>: <problem>; …`).
+ */
+export type PackageCheck<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    issues: string[];
+    message: string;
+};
+/** Check a parsed `plugin-spec.yaml` document against {@link PluginSpecSchema}. */
+export declare function checkPluginSpec(raw: unknown): PackageCheck<PluginSpecInput>;
+/** Check a parsed `config.yaml` document against {@link PluginConfigSchema}. */
+export declare function checkPluginConfig(raw: unknown): PackageCheck<PluginConfigInput>;
+/**
+ * The required-field contract: `name` and `version` always, `commands` for
+ * every type except `ManualApprovalStep`. Returns the upload's message, or null.
+ */
+export declare function pluginSpecRequiredFieldsProblem(spec: Pick<PluginSpecInput, 'name' | 'version' | 'commands' | 'pluginType'>): string | null;