@pipeline-builder/api-core 4.1.13 → 4.1.15

package/lib/validation/plugin-catalog-metadata.js

@@ -0,0 +1,162 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Plugin CATALOG metadata: the descriptive fields a plugin version shows in the
+ * catalog, detected from the package and then accepted or edited by the user
+ * (docs/plugin-publishing.md).
+ *
+ * ONE validator for both paths: a value detected from the package (spec,
+ * README, the plugin's own Dockerfile labels) and a value typed into a form or
+ * sent by the CLI pass the same rules. Shared from api-core so the plugin
+ * service, the frontend and the CLI can't drift.
+ *
+ * Only DESCRIPTIVE fields live here. Execution-contract fields (commands, env,
+ * secrets, compute type, …) are spec-only — changing one is a new version with a
+ * new digest — and an edit payload naming one is refused
+ * ({@link findContractKeys}).
+ */
+import { z } from 'zod';
+import { PLUGIN_CATALOG_FIELDS, PLUGIN_CATEGORIES, PLUGIN_CHANGELOG_MAX_BYTES, PLUGIN_DESCRIPTION_MAX, PLUGIN_DISPLAY_NAME_MAX, PLUGIN_KEYWORD_MAX_LENGTH, PLUGIN_KEYWORDS_MAX, PLUGIN_README_MAX_BYTES, PLUGIN_SUMMARY_MAX, PLUGIN_URL_MAX, } from '../types/plugin-catalog.js';
+/**
+ * Accepted SPDX license identifiers — a compact allowlist of the ids that
+ * cover effectively every published plugin, rather than the full ~700-entry
+ * SPDX list (an unfamiliar id is worth a human look). Case-sensitive, exactly
+ * as SPDX spells them. `LicenseRef-Proprietary` is the SPDX-sanctioned
+ * spelling for "not open source".
+ */
+export const SPDX_LICENSE_IDS = new Set([
+    'Apache-2.0', 'MIT', 'MIT-0', 'ISC', '0BSD', 'Unlicense', 'CC0-1.0', 'Zlib', 'BSL-1.0',
+    'BSD-2-Clause', 'BSD-3-Clause',
+    'MPL-2.0', 'EPL-1.0', 'EPL-2.0',
+    'LGPL-2.1-only', 'LGPL-2.1-or-later', 'LGPL-3.0-only', 'LGPL-3.0-or-later',
+    'GPL-2.0-only', 'GPL-2.0-or-later', 'GPL-3.0-only', 'GPL-3.0-or-later',
+    'AGPL-3.0-only', 'AGPL-3.0-or-later',
+    'CC-BY-4.0', 'CC-BY-SA-4.0', 'Python-2.0', 'PostgreSQL', 'Artistic-2.0',
+    'BUSL-1.1', 'Elastic-2.0', 'SSPL-1.0',
+    'LicenseRef-Proprietary',
+]);
+/** True when `id` is an accepted SPDX identifier. */
+export function isAllowedSpdxId(id) {
+    return SPDX_LICENSE_IDS.has(id);
+}
+/**
+ * URL shorteners refused in project links: a shortener hides the destination
+ * from the reviewer and can be re-pointed after approval.
+ */
+export const URL_SHORTENER_HOSTS = new Set([
+    'bit.ly', 't.co', 'tinyurl.com', 'goo.gl', 'ow.ly', 'is.gd', 'buff.ly', 'rebrand.ly', 'cutt.ly', 'shorturl.at',
+]);
+/**
+ * Why `raw` is not an acceptable project URL, or `null` when it is: must parse,
+ * be `https:`, carry no userinfo, and not point at a known shortener (the host
+ * or any parent domain of it).
+ */
+export function projectUrlProblem(raw) {
+    if (raw.length > PLUGIN_URL_MAX)
+        return `must be at most ${PLUGIN_URL_MAX} characters`;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return 'must be an absolute URL';
+    }
+    if (url.protocol !== 'https:')
+        return 'must use https';
+    if (url.username || url.password)
+        return 'must not embed credentials';
+    const host = url.hostname.toLowerCase().replace(/\.$/, '');
+    const labels = host.split('.');
+    for (let i = 0; i < labels.length - 1; i++) {
+        if (URL_SHORTENER_HOSTS.has(labels.slice(i).join('.')))
+            return `must not use a URL shortener (${host})`;
+    }
+    return null;
+}
+/** Curated icon / badge key: a file name under `deploy/plugins/_icons/`. */
+export const ICON_KEY_PATTERN = /^[a-z0-9-]+$/;
+// -----------------------------------------------------------------------------
+// Field schemas
+// -----------------------------------------------------------------------------
+const utf8Bytes = (v) => new TextEncoder().encode(v).length;
+/** `https:` project URL, no shorteners, no credentials. */
+export const ProjectUrlSchema = z.string().superRefine((v, ctx) => {
+    const problem = projectUrlProblem(v);
+    if (problem)
+        ctx.addIssue({ code: 'custom', message: problem });
+});
+/** Curated icon / badge key. */
+export const IconKeySchema = z.string().max(64).regex(ICON_KEY_PATTERN, 'must match ^[a-z0-9-]+$');
+/**
+ * Icon as stored: `{ key, badge? }`. A bare key string is accepted and
+ * normalized first, so a bad key reports the key rule (not a bare union miss).
+ */
+export const PluginIconSchema = z.preprocess((v) => (typeof v === 'string' ? { key: v } : v), z.object({ key: IconKeySchema, badge: IconKeySchema.optional() }).strict());
+/** A non-empty single-line-ish text field with a character cap. */
+const text = (max) => z.string().trim().min(1, 'must not be empty').max(max, `must be at most ${max} characters`);
+/**
+ * Per-field validators for every DESCRIPTIVE field. A detected value
+ * and a user-typed value both go through these.
+ */
+export const PLUGIN_CATALOG_FIELD_SCHEMAS = {
+    summary: text(PLUGIN_SUMMARY_MAX),
+    description: text(PLUGIN_DESCRIPTION_MAX),
+    displayName: text(PLUGIN_DISPLAY_NAME_MAX),
+    category: z.enum(PLUGIN_CATEGORIES, { message: `must be one of: ${PLUGIN_CATEGORIES.join(', ')}` }),
+    keywords: z.array(z.string().trim().min(1, 'keywords must not be empty').max(PLUGIN_KEYWORD_MAX_LENGTH, `each keyword must be at most ${PLUGIN_KEYWORD_MAX_LENGTH} characters`)).max(PLUGIN_KEYWORDS_MAX, `at most ${PLUGIN_KEYWORDS_MAX} keywords`),
+    license: z.string().refine(isAllowedSpdxId, { message: 'must be a supported SPDX license identifier (e.g. Apache-2.0, MIT)' }),
+    homepageUrl: ProjectUrlSchema,
+    sourceUrl: ProjectUrlSchema,
+    documentationUrl: ProjectUrlSchema,
+    icon: PluginIconSchema,
+    changelog: z.string().refine((v) => utf8Bytes(v) <= PLUGIN_CHANGELOG_MAX_BYTES, {
+        message: `must be at most ${PLUGIN_CHANGELOG_MAX_BYTES} bytes`,
+    }),
+    readme: z.string().refine((v) => utf8Bytes(v) <= PLUGIN_README_MAX_BYTES, {
+        message: `must be at most ${PLUGIN_README_MAX_BYTES} bytes`,
+    }),
+};
+/**
+ * Catalog EDITS (the upload's `metadata` part, a `PUT /plugins/:id` body's
+ * descriptive keys, the CLI's `--metadata` file). `null` clears a field.
+ * Strict: an unknown key is an error, never silently dropped.
+ */
+export const PluginCatalogEditsSchema = z.object(Object.fromEntries(PLUGIN_CATALOG_FIELDS.map((f) => [f, PLUGIN_CATALOG_FIELD_SCHEMAS[f].nullable().optional()]))).strict();
+/**
+ * Validate one field's value. Returns the normalized value (trimmed text, an
+ * icon string as `{ key }`) or the reason it was refused — so a detected value
+ * that fails is shown BLANK WITH THE REASON rather than silently dropped.
+ */
+export function validateCatalogField(field, value) {
+    const result = PLUGIN_CATALOG_FIELD_SCHEMAS[field].safeParse(value);
+    if (result.success)
+        return { ok: true, value: result.data };
+    return { ok: false, error: result.error.issues.map((i) => i.message).join('; ') };
+}
+// -----------------------------------------------------------------------------
+// Execution contract (never editable)
+// -----------------------------------------------------------------------------
+/**
+ * Keys that describe WHAT RUNS. They come only from the spec: changing one is a
+ * new version, a new digest and a review diff. A metadata edit
+ * naming any of them is refused with 400 — the refusal is the API's, not just
+ * the UI's. `name`/`version` key the pushed image and are immutable too.
+ */
+export const PLUGIN_CONTRACT_FIELDS = [
+    'name', 'version',
+    'commands', 'installCommands', 'env', 'buildArgs', 'secrets',
+    'metadata', 'requiredMetadata', 'requiredVars', 'metadataTypes', 'varsTypes',
+    'network', 'networkEgress', 'computeType', 'pluginType', 'primaryOutputDirectory',
+    'smokeTest', 'timeout', 'failureBehavior', 'dockerfile', 'buildType',
+];
+/** The execution-contract keys present in `payload` (empty when none). */
+export function findContractKeys(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return [];
+    return PLUGIN_CONTRACT_FIELDS.filter((k) => Object.prototype.hasOwnProperty.call(payload, k));
+}
+/** The message a contract-key refusal carries. */
+export function contractKeysMessage(keys) {
+    return `These fields define what the plugin runs and can only change by uploading a new version: ${keys.join(', ')}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-catalog-metadata.js","sourceRoot":"","sources":["../../src/validation/plugin-catalog-metadata.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Plugin CATALOG metadata: the descriptive fields a plugin version shows in the\n * catalog, detected from the package and then accepted or edited by the user\n * (docs/plugin-publishing.md).\n *\n * ONE validator for both paths: a value detected from the package (spec,\n * README, the plugin's own Dockerfile labels) and a value typed into a form or\n * sent by the CLI pass the same rules. Shared from api-core so the plugin\n * service, the frontend and the CLI can't drift.\n *\n * Only DESCRIPTIVE fields live here. Execution-contract fields (commands, env,\n * secrets, compute type, …) are spec-only — changing one is a new version with a\n * new digest — and an edit payload naming one is refused\n * ({@link findContractKeys}).\n */\n\nimport { z } from 'zod';\nimport {\n  PLUGIN_CATALOG_FIELDS,\n  PLUGIN_CATEGORIES,\n  PLUGIN_CHANGELOG_MAX_BYTES,\n  PLUGIN_DESCRIPTION_MAX,\n  PLUGIN_DISPLAY_NAME_MAX,\n  PLUGIN_KEYWORD_MAX_LENGTH,\n  PLUGIN_KEYWORDS_MAX,\n  PLUGIN_README_MAX_BYTES,\n  PLUGIN_SUMMARY_MAX,\n  PLUGIN_URL_MAX,\n  type PluginCatalogField,\n} from '../types/plugin-catalog.js';\n\n/**\n * Accepted SPDX license identifiers — a compact allowlist of the ids that\n * cover effectively every published plugin, rather than the full ~700-entry\n * SPDX list (an unfamiliar id is worth a human look). Case-sensitive, exactly\n * as SPDX spells them. `LicenseRef-Proprietary` is the SPDX-sanctioned\n * spelling for \"not open source\".\n */\nexport const SPDX_LICENSE_IDS: ReadonlySet<string> = new Set([\n  'Apache-2.0', 'MIT', 'MIT-0', 'ISC', '0BSD', 'Unlicense', 'CC0-1.0', 'Zlib', 'BSL-1.0',\n  'BSD-2-Clause', 'BSD-3-Clause',\n  'MPL-2.0', 'EPL-1.0', 'EPL-2.0',\n  'LGPL-2.1-only', 'LGPL-2.1-or-later', 'LGPL-3.0-only', 'LGPL-3.0-or-later',\n  'GPL-2.0-only', 'GPL-2.0-or-later', 'GPL-3.0-only', 'GPL-3.0-or-later',\n  'AGPL-3.0-only', 'AGPL-3.0-or-later',\n  'CC-BY-4.0', 'CC-BY-SA-4.0', 'Python-2.0', 'PostgreSQL', 'Artistic-2.0',\n  'BUSL-1.1', 'Elastic-2.0', 'SSPL-1.0',\n  'LicenseRef-Proprietary',\n]);\n\n/** True when `id` is an accepted SPDX identifier. */\nexport function isAllowedSpdxId(id: string): boolean {\n  return SPDX_LICENSE_IDS.has(id);\n}\n\n/**\n * URL shorteners refused in project links: a shortener hides the destination\n * from the reviewer and can be re-pointed after approval.\n */\nexport const URL_SHORTENER_HOSTS: ReadonlySet<string> = new Set([\n  'bit.ly', 't.co', 'tinyurl.com', 'goo.gl', 'ow.ly', 'is.gd', 'buff.ly', 'rebrand.ly', 'cutt.ly', 'shorturl.at',\n]);\n\n/**\n * Why `raw` is not an acceptable project URL, or `null` when it is: must parse,\n * be `https:`, carry no userinfo, and not point at a known shortener (the host\n * or any parent domain of it).\n */\nexport function projectUrlProblem(raw: string): string | null {\n  if (raw.length > PLUGIN_URL_MAX) return `must be at most ${PLUGIN_URL_MAX} characters`;\n  let url: URL;\n  try {\n    url = new URL(raw);\n  } catch {\n    return 'must be an absolute URL';\n  }\n  if (url.protocol !== 'https:') return 'must use https';\n  if (url.username || url.password) return 'must not embed credentials';\n  const host = url.hostname.toLowerCase().replace(/\\.$/, '');\n  const labels = host.split('.');\n  for (let i = 0; i < labels.length - 1; i++) {\n    if (URL_SHORTENER_HOSTS.has(labels.slice(i).join('.'))) return `must not use a URL shortener (${host})`;\n  }\n  return null;\n}\n\n/** Curated icon / badge key: a file name under `deploy/plugins/_icons/`. */\nexport const ICON_KEY_PATTERN = /^[a-z0-9-]+$/;\n\n// -----------------------------------------------------------------------------\n// Field schemas\n// -----------------------------------------------------------------------------\n\nconst utf8Bytes = (v: string): number => new TextEncoder().encode(v).length;\n\n/** `https:` project URL, no shorteners, no credentials. */\nexport const ProjectUrlSchema = z.string().superRefine((v, ctx) => {\n  const problem = projectUrlProblem(v);\n  if (problem) ctx.addIssue({ code: 'custom', message: problem });\n});\n\n/** Curated icon / badge key. */\nexport const IconKeySchema = z.string().max(64).regex(ICON_KEY_PATTERN, 'must match ^[a-z0-9-]+$');\n\n/**\n * Icon as stored: `{ key, badge? }`. A bare key string is accepted and\n * normalized first, so a bad key reports the key rule (not a bare union miss).\n */\nexport const PluginIconSchema = z.preprocess(\n  (v) => (typeof v === 'string' ? { key: v } : v),\n  z.object({ key: IconKeySchema, badge: IconKeySchema.optional() }).strict(),\n);\n\n/** A non-empty single-line-ish text field with a character cap. */\nconst text = (max: number) => z.string().trim().min(1, 'must not be empty').max(max, `must be at most ${max} characters`);\n\n/**\n * Per-field validators for every DESCRIPTIVE field. A detected value\n * and a user-typed value both go through these.\n */\nexport const PLUGIN_CATALOG_FIELD_SCHEMAS = {\n  summary: text(PLUGIN_SUMMARY_MAX),\n  description: text(PLUGIN_DESCRIPTION_MAX),\n  displayName: text(PLUGIN_DISPLAY_NAME_MAX),\n  category: z.enum(PLUGIN_CATEGORIES, { message: `must be one of: ${PLUGIN_CATEGORIES.join(', ')}` }),\n  keywords: z.array(\n    z.string().trim().min(1, 'keywords must not be empty').max(PLUGIN_KEYWORD_MAX_LENGTH, `each keyword must be at most ${PLUGIN_KEYWORD_MAX_LENGTH} characters`),\n  ).max(PLUGIN_KEYWORDS_MAX, `at most ${PLUGIN_KEYWORDS_MAX} keywords`),\n  license: z.string().refine(isAllowedSpdxId, { message: 'must be a supported SPDX license identifier (e.g. Apache-2.0, MIT)' }),\n  homepageUrl: ProjectUrlSchema,\n  sourceUrl: ProjectUrlSchema,\n  documentationUrl: ProjectUrlSchema,\n  icon: PluginIconSchema,\n  changelog: z.string().refine((v) => utf8Bytes(v) <= PLUGIN_CHANGELOG_MAX_BYTES, {\n    message: `must be at most ${PLUGIN_CHANGELOG_MAX_BYTES} bytes`,\n  }),\n  readme: z.string().refine((v) => utf8Bytes(v) <= PLUGIN_README_MAX_BYTES, {\n    message: `must be at most ${PLUGIN_README_MAX_BYTES} bytes`,\n  }),\n} as const satisfies Record<PluginCatalogField, z.ZodType>;\n\n/**\n * Catalog EDITS (the upload's `metadata` part, a `PUT /plugins/:id` body's\n * descriptive keys, the CLI's `--metadata` file). `null` clears a field.\n * Strict: an unknown key is an error, never silently dropped.\n */\nexport const PluginCatalogEditsSchema = z.object(\n  Object.fromEntries(PLUGIN_CATALOG_FIELDS.map((f) => [f, PLUGIN_CATALOG_FIELD_SCHEMAS[f].nullable().optional()])) as {\n    [K in PluginCatalogField]: z.ZodOptional<z.ZodNullable<typeof PLUGIN_CATALOG_FIELD_SCHEMAS[K]>>;\n  },\n).strict();\nexport type PluginCatalogEdits = z.infer<typeof PluginCatalogEditsSchema>;\n\n/**\n * Validate one field's value. Returns the normalized value (trimmed text, an\n * icon string as `{ key }`) or the reason it was refused — so a detected value\n * that fails is shown BLANK WITH THE REASON rather than silently dropped.\n */\nexport function validateCatalogField<F extends PluginCatalogField>(\n  field: F,\n  value: unknown,\n): { ok: true; value: z.infer<typeof PLUGIN_CATALOG_FIELD_SCHEMAS[F]> } | { ok: false; error: string } {\n  const result = (PLUGIN_CATALOG_FIELD_SCHEMAS[field] as z.ZodType).safeParse(value);\n  if (result.success) return { ok: true, value: result.data as z.infer<typeof PLUGIN_CATALOG_FIELD_SCHEMAS[F]> };\n  return { ok: false, error: result.error.issues.map((i) => i.message).join('; ') };\n}\n\n// -----------------------------------------------------------------------------\n// Execution contract (never editable)\n// -----------------------------------------------------------------------------\n\n/**\n * Keys that describe WHAT RUNS. They come only from the spec: changing one is a\n * new version, a new digest and a review diff. A metadata edit\n * naming any of them is refused with 400 — the refusal is the API's, not just\n * the UI's. `name`/`version` key the pushed image and are immutable too.\n */\nexport const PLUGIN_CONTRACT_FIELDS = [\n  'name', 'version',\n  'commands', 'installCommands', 'env', 'buildArgs', 'secrets',\n  'metadata', 'requiredMetadata', 'requiredVars', 'metadataTypes', 'varsTypes',\n  'network', 'networkEgress', 'computeType', 'pluginType', 'primaryOutputDirectory',\n  'smokeTest', 'timeout', 'failureBehavior', 'dockerfile', 'buildType',\n] as const;\n\n/** The execution-contract keys present in `payload` (empty when none). */\nexport function findContractKeys(payload: unknown): string[] {\n  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return [];\n  return PLUGIN_CONTRACT_FIELDS.filter((k) => Object.prototype.hasOwnProperty.call(payload, k));\n}\n\n/** The message a contract-key refusal carries. */\nexport function contractKeysMessage(keys: readonly string[]): string {\n  return `These fields define what the plugin runs and can only change by uploading a new version: ${keys.join(', ')}`;\n}\n"]}

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

@@ -0,0 +1,41 @@
+export type HeuristicSeverity = 'high' | 'medium';
+export interface HeuristicFinding {
+    /** Rule id (stable; moderators filter on it). */
+    id: string;
+    severity: HeuristicSeverity;
+    /** The file, relative to the package root. */
+    path: string;
+    /** 1-based line number. */
+    line: number;
+    /** The offending line, trimmed and capped, with secret values masked. */
+    excerpt: string;
+    /** What the rule means. */
+    message: string;
+}
+export interface HeuristicsReport {
+    findings: HeuristicFinding[];
+    /** Files scanned. */
+    scannedFiles: number;
+    /** Files skipped (binary, over the size cap, or past the total budget). */
+    skippedFiles: string[];
+}
+export interface HeuristicsInputFile {
+    path: string;
+    content: string | Uint8Array;
+}
+/** A single file larger than this is not scanned (listed in `skippedFiles`). */
+export declare const HEURISTICS_MAX_FILE_BYTES: number;
+/** Total bytes scanned per package. */
+export declare const HEURISTICS_MAX_TOTAL_BYTES: number;
+/** Findings kept per package. */
+export declare const HEURISTICS_MAX_FINDINGS = 200;
+/** Shannon entropy of `s`, in bits per character. */
+export declare function shannonEntropy(s: string): number;
+/**
+ * Scan a plugin package's files. `files` paths are package-relative; a
+ * Dockerfile is recognised by name (`Dockerfile`, `*.Dockerfile`,
+ * `Dockerfile.*`). Deterministic: findings come back in file then line order.
+ */
+export declare function scanPluginSourceHeuristics(files: readonly HeuristicsInputFile[]): HeuristicsReport;
+/** The findings that fail a gate (`high`). */
+export declare function blockingHeuristics(report: Pick<HeuristicsReport, 'findings'>): HeuristicFinding[];

package/lib/validation/plugin-heuristics.js

@@ -0,0 +1,211 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Malware heuristics over a plugin PACKAGE's source (docs/plugin-publishing.md,
+ * the automated submission gate): the Dockerfile, the spec and every other text file in the
+ * zip. A plugin runs inside a customer's CodeBuild with the customer's keys, so
+ * the patterns looked for are the ones that abuse exactly that:
+ *
+ *  - crypto-miner signatures (xmrig, `stratum+tcp://`, cryptonight, …);
+ *  - obfuscated execution (a base64/hex blob decoded into a shell or `eval`,
+ *    `eval "$(… | base64 -d)"`, long single-line encoded payloads);
+ *  - credential access (`AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, the ECS /
+ *    CodeBuild container-credential endpoints and variables, IMDS
+ *    `169.254.169.254` / `fd00:ec2::254`, `~/.aws/credentials`,
+ *    `/var/run/secrets`);
+ *  - reverse shells and unchecked pipe-to-shell downloads;
+ *  - secret-looking literals (`AKIA…`, `ghp_…`, `xoxb-…`, PEM private keys, a
+ *    high-entropy value assigned to a `*_TOKEN` / `*_SECRET` / `*_PASSWORD` /
+ *    `*_KEY` name).
+ *
+ * `high` findings fail the anonymous-submission gate; `medium` ones are shown
+ * to moderators only. The CLI (`plugin validate` / `plugin publish`) runs the
+ * same scan so an author sees it before uploading. Pure and bounded: files and
+ * lines are size-capped, binary files are skipped, and findings are capped.
+ */
+import { pipeInstallers } from './plugin-lint.js';
+/** A single file larger than this is not scanned (listed in `skippedFiles`). */
+export const HEURISTICS_MAX_FILE_BYTES = 512 * 1024;
+/** Total bytes scanned per package. */
+export const HEURISTICS_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+/** Findings kept per package. */
+export const HEURISTICS_MAX_FINDINGS = 200;
+const EXCERPT_MAX = 160;
+/** A line longer than this is scanned only for the encoded-blob rule (and truncated for the rest). */
+const LINE_SCAN_MAX = 8 * 1024;
+const SHELL = String.raw `(?:sudo\s+)?(?:\/usr)?(?:\/bin\/)?(?:ba|da|z|k)?sh\b`;
+const LINE_RULES = [
+    {
+        id: 'miner-signature',
+        severity: 'high',
+        message: 'Crypto-miner signature',
+        test: /\bxmrig\b|stratum\+(?:tcp|ssl|tls):\/\/|\bcryptonight\b|\bminerd\b|\bnicehash\b|\bcpuminer\b|\bxmr-stak\b|\bethminer\b|\bnbminer\b|\bphoenixminer\b|\blolminer\b|\bsupportxmr\b|\bminexmr\b|\bmoneroocean\b/i,
+    },
+    {
+        id: 'obfuscated-exec',
+        severity: 'high',
+        message: 'Encoded payload decoded straight into a shell or eval',
+        test: new RegExp(String.raw `base64\s+(?:-d|-D|--decode)\b[^\n]*\|\s*${SHELL}|\beval\b[^\n]*\$\([^\n]*base64\s+(?:-d|-D|--decode)|\bxxd\s+-r\b[^\n]*\|\s*${SHELL}|(?:\\x[0-9a-fA-F]{2}){8,}[^\n]*\|\s*${SHELL}|\bexec\s*\(\s*(?:base64\.b64decode|__import__\(\s*['"](?:base64|zlib)['"])|\beval\s*\(\s*(?:atob|Buffer\.from)\s*\(`, 'i'),
+    },
+    {
+        id: 'reverse-shell',
+        severity: 'high',
+        message: 'Reverse-shell pattern',
+        test: /\/dev\/tcp\/\d|\bnc(?:at)?\b[^\n]*\s-(?:e|c)\s+\S*sh\b|\bncat\b[^\n]*--(?:exec|sh-exec)\b|\bsocat\b[^\n]*\bexec:/i,
+    },
+    {
+        id: 'credential-access',
+        severity: 'high',
+        docSeverity: 'medium',
+        codeOnly: true,
+        message: 'Reads cloud or build credentials',
+        test: /\bAWS_SECRET_ACCESS_KEY\b|\bAWS_SESSION_TOKEN\b|\bAWS_CONTAINER_CREDENTIALS_(?:RELATIVE|FULL)_URI\b|\bAWS_CONTAINER_AUTHORIZATION_TOKEN(?:_FILE)?\b|\bCODEBUILD_[A-Z0-9_]*(?:TOKEN|CREDENTIAL|SECRET|AUTH)[A-Z0-9_]*\b|169\.254\.169\.254|169\.254\.170\.2|fd00:ec2::254|\.aws\/credentials|\/var\/run\/secrets\b/,
+    },
+    {
+        id: 'pipe-to-shell',
+        severity: 'high',
+        docSeverity: null,
+        codeOnly: true,
+        message: 'Download piped straight into a shell',
+        test: new RegExp(String.raw `\b(?:curl|wget)\b[^\n|]*\|\s*${SHELL}`, 'i'),
+    },
+    {
+        id: 'secret-literal',
+        severity: 'high',
+        message: 'Secret-looking literal',
+        secret: true,
+        test: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b|\bgh[pousr]_[A-Za-z0-9]{36,}\b|\bgithub_pat_[A-Za-z0-9_]{40,}\b|\bxox[bap]-[A-Za-z0-9-]{10,}|-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----|\bglpat-[A-Za-z0-9_-]{20,}\b|\bsk_live_[A-Za-z0-9]{16,}\b/,
+    },
+];
+/** `NAME=value` / `NAME: value` / `ENV NAME value` assignments to a secret-looking name. */
+const SECRET_ASSIGNMENT = /\b([A-Za-z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY|ACCESS_KEY|_KEY))\b["']?\s*(?:[:=]|\s)\s*["']?([^\s"'`,;)]{16,})/i;
+/** A long single-token base64 or hex run (an embedded payload). */
+const ENCODED_BLOB = /[A-Za-z0-9+/]{240,}={0,2}|\b[0-9a-fA-F]{240,}\b/;
+/** Shannon entropy of `s`, in bits per character. */
+export function shannonEntropy(s) {
+    if (!s)
+        return 0;
+    const counts = new Map();
+    for (const ch of s)
+        counts.set(ch, (counts.get(ch) ?? 0) + 1);
+    let h = 0;
+    for (const n of counts.values()) {
+        const p = n / s.length;
+        h -= p * Math.log2(p);
+    }
+    return h;
+}
+/** Whether a secret-assignment value looks like a real credential (not a placeholder or a reference). */
+function looksLikeSecretValue(value) {
+    if (/[$]|\{\{|<|>|\*{3,}|x{6,}|changeme|example|placeholder|your[-_]/i.test(value))
+        return false;
+    return shannonEntropy(value) >= 3.5;
+}
+function isDocFile(path) {
+    return /(^|\/)readme(\.[a-z]+)?$/i.test(path) || /\.(md|markdown|rst|txt|adoc)$/i.test(path);
+}
+function mask(line) {
+    return line
+        .replace(/\b((?:AKIA|ASIA)[0-9A-Z]{4})[0-9A-Z]{12}\b/g, '$1…')
+        .replace(/\b(gh[pousr]_|github_pat_|xox[bap]-|glpat-|sk_live_)[A-Za-z0-9_-]+/g, '$1…')
+        .replace(SECRET_ASSIGNMENT, (m, _name, value) => m.replace(value, `${value.slice(0, 4)}…`));
+}
+function excerptOf(line, secret) {
+    const t = (secret ? mask(line) : line).trim();
+    return t.length > EXCERPT_MAX ? `${t.slice(0, EXCERPT_MAX - 1)}…` : t;
+}
+/** Whether a decoded buffer looks binary (a NUL in its first 8 KiB). */
+function isBinary(bytes) {
+    const n = Math.min(bytes.length, 8192);
+    for (let i = 0; i < n; i++)
+        if (bytes[i] === 0)
+            return true;
+    return false;
+}
+function asText(content) {
+    if (typeof content === 'string')
+        return { text: content.includes('\u0000') ? null : content, bytes: Buffer.byteLength(content) };
+    if (isBinary(content))
+        return { text: null, bytes: content.length };
+    return { text: Buffer.from(content).toString('utf8'), bytes: content.length };
+}
+/**
+ * Scan a plugin package's files. `files` paths are package-relative; a
+ * Dockerfile is recognised by name (`Dockerfile`, `*.Dockerfile`,
+ * `Dockerfile.*`). Deterministic: findings come back in file then line order.
+ */
+export function scanPluginSourceHeuristics(files) {
+    const findings = [];
+    const skippedFiles = [];
+    const seen = new Set();
+    let scannedFiles = 0;
+    let budget = HEURISTICS_MAX_TOTAL_BYTES;
+    const add = (f) => {
+        const key = `${f.id}|${f.path}|${f.line}`;
+        if (seen.has(key) || findings.length >= HEURISTICS_MAX_FINDINGS)
+            return;
+        seen.add(key);
+        findings.push(f);
+    };
+    for (const file of files) {
+        const { text, bytes } = asText(file.content);
+        if (text === null || bytes > HEURISTICS_MAX_FILE_BYTES || bytes > budget) {
+            skippedFiles.push(file.path);
+            continue;
+        }
+        budget -= bytes;
+        scannedFiles++;
+        const doc = isDocFile(file.path);
+        const lines = text.replace(/\r\n?/g, '\n').split('\n');
+        lines.forEach((raw, idx) => {
+            const line = idx + 1;
+            if (ENCODED_BLOB.test(raw)) {
+                add({ id: 'encoded-blob', severity: 'medium', path: file.path, line, excerpt: excerptOf(raw, false), message: 'Long single-line encoded payload' });
+            }
+            const scan = raw.length > LINE_SCAN_MAX ? raw.slice(0, LINE_SCAN_MAX) : raw;
+            const comment = /^\s*(#|\/\/)/.test(scan);
+            for (const rule of LINE_RULES) {
+                if (rule.codeOnly && comment)
+                    continue;
+                if (!rule.test.test(scan))
+                    continue;
+                const severity = doc && rule.docSeverity !== undefined ? rule.docSeverity : rule.severity;
+                if (severity === null)
+                    continue;
+                add({ id: rule.id, severity, path: file.path, line, excerpt: excerptOf(scan, rule.secret === true), message: rule.message });
+            }
+            const assignment = SECRET_ASSIGNMENT.exec(scan);
+            if (assignment && looksLikeSecretValue(assignment[2])) {
+                add({
+                    id: 'secret-default',
+                    severity: doc ? 'medium' : 'high',
+                    path: file.path,
+                    line,
+                    excerpt: excerptOf(scan, true),
+                    message: `High-entropy value assigned to ${assignment[1]}`,
+                });
+            }
+        });
+        // Dockerfile RUN lines that pipe a download into a shell, continuation-joined
+        // (the line rule above only sees one physical line).
+        if (/(^|\/)(Dockerfile(\.[^/]+)?|[^/]+\.Dockerfile)$/i.test(file.path)) {
+            for (const instruction of pipeInstallers(text)) {
+                const firstLine = lines.findIndex((l) => l.trim() !== '' && instruction.startsWith(l.trim().replace(/\\\s*$/, '').trim()));
+                add({
+                    id: 'pipe-to-shell',
+                    severity: 'high',
+                    path: file.path,
+                    line: firstLine >= 0 ? firstLine + 1 : 1,
+                    excerpt: excerptOf(instruction, false),
+                    message: 'Download piped straight into a shell',
+                });
+            }
+        }
+    }
+    return { findings, scannedFiles, skippedFiles };
+}
+/** The findings that fail a gate (`high`). */
+export function blockingHeuristics(report) {
+    return report.findings.filter((f) => f.severity === 'high');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-heuristics.js","sourceRoot":"","sources":["../../src/validation/plugin-heuristics.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Malware heuristics over a plugin PACKAGE's source (docs/plugin-publishing.md,\n * the automated submission gate): the Dockerfile, the spec and every other text file in the\n * zip. A plugin runs inside a customer's CodeBuild with the customer's keys, so\n * the patterns looked for are the ones that abuse exactly that:\n *\n *  - crypto-miner signatures (xmrig, `stratum+tcp://`, cryptonight, …);\n *  - obfuscated execution (a base64/hex blob decoded into a shell or `eval`,\n *    `eval \"$(… | base64 -d)\"`, long single-line encoded payloads);\n *  - credential access (`AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, the ECS /\n *    CodeBuild container-credential endpoints and variables, IMDS\n *    `169.254.169.254` / `fd00:ec2::254`, `~/.aws/credentials`,\n *    `/var/run/secrets`);\n *  - reverse shells and unchecked pipe-to-shell downloads;\n *  - secret-looking literals (`AKIA…`, `ghp_…`, `xoxb-…`, PEM private keys, a\n *    high-entropy value assigned to a `*_TOKEN` / `*_SECRET` / `*_PASSWORD` /\n *    `*_KEY` name).\n *\n * `high` findings fail the anonymous-submission gate; `medium` ones are shown\n * to moderators only. The CLI (`plugin validate` / `plugin publish`) runs the\n * same scan so an author sees it before uploading. Pure and bounded: files and\n * lines are size-capped, binary files are skipped, and findings are capped.\n */\n\nimport { pipeInstallers } from './plugin-lint.js';\n\nexport type HeuristicSeverity = 'high' | 'medium';\n\nexport interface HeuristicFinding {\n  /** Rule id (stable; moderators filter on it). */\n  id: string;\n  severity: HeuristicSeverity;\n  /** The file, relative to the package root. */\n  path: string;\n  /** 1-based line number. */\n  line: number;\n  /** The offending line, trimmed and capped, with secret values masked. */\n  excerpt: string;\n  /** What the rule means. */\n  message: string;\n}\n\nexport interface HeuristicsReport {\n  findings: HeuristicFinding[];\n  /** Files scanned. */\n  scannedFiles: number;\n  /** Files skipped (binary, over the size cap, or past the total budget). */\n  skippedFiles: string[];\n}\n\nexport interface HeuristicsInputFile {\n  path: string;\n  content: string | Uint8Array;\n}\n\n/** A single file larger than this is not scanned (listed in `skippedFiles`). */\nexport const HEURISTICS_MAX_FILE_BYTES = 512 * 1024;\n/** Total bytes scanned per package. */\nexport const HEURISTICS_MAX_TOTAL_BYTES = 16 * 1024 * 1024;\n/** Findings kept per package. */\nexport const HEURISTICS_MAX_FINDINGS = 200;\nconst EXCERPT_MAX = 160;\n/** A line longer than this is scanned only for the encoded-blob rule (and truncated for the rest). */\nconst LINE_SCAN_MAX = 8 * 1024;\n\ninterface LineRule {\n  id: string;\n  severity: HeuristicSeverity;\n  message: string;\n  test: RegExp;\n  /** Severity in documentation files (README, *.md), where mentioning a name isn't using it. */\n  docSeverity?: HeuristicSeverity | null;\n  /** Mask secret-looking values in the excerpt. */\n  secret?: boolean;\n  /** Only on code lines: a `#` / `//` comment that MENTIONS the pattern isn't using it. */\n  codeOnly?: boolean;\n}\n\nconst SHELL = String.raw`(?:sudo\\s+)?(?:\\/usr)?(?:\\/bin\\/)?(?:ba|da|z|k)?sh\\b`;\n\nconst LINE_RULES: readonly LineRule[] = [\n  {\n    id: 'miner-signature',\n    severity: 'high',\n    message: 'Crypto-miner signature',\n    test: /\\bxmrig\\b|stratum\\+(?:tcp|ssl|tls):\\/\\/|\\bcryptonight\\b|\\bminerd\\b|\\bnicehash\\b|\\bcpuminer\\b|\\bxmr-stak\\b|\\bethminer\\b|\\bnbminer\\b|\\bphoenixminer\\b|\\blolminer\\b|\\bsupportxmr\\b|\\bminexmr\\b|\\bmoneroocean\\b/i,\n  },\n  {\n    id: 'obfuscated-exec',\n    severity: 'high',\n    message: 'Encoded payload decoded straight into a shell or eval',\n    test: new RegExp(String.raw`base64\\s+(?:-d|-D|--decode)\\b[^\\n]*\\|\\s*${SHELL}|\\beval\\b[^\\n]*\\$\\([^\\n]*base64\\s+(?:-d|-D|--decode)|\\bxxd\\s+-r\\b[^\\n]*\\|\\s*${SHELL}|(?:\\\\x[0-9a-fA-F]{2}){8,}[^\\n]*\\|\\s*${SHELL}|\\bexec\\s*\\(\\s*(?:base64\\.b64decode|__import__\\(\\s*['\"](?:base64|zlib)['\"])|\\beval\\s*\\(\\s*(?:atob|Buffer\\.from)\\s*\\(`, 'i'),\n  },\n  {\n    id: 'reverse-shell',\n    severity: 'high',\n    message: 'Reverse-shell pattern',\n    test: /\\/dev\\/tcp\\/\\d|\\bnc(?:at)?\\b[^\\n]*\\s-(?:e|c)\\s+\\S*sh\\b|\\bncat\\b[^\\n]*--(?:exec|sh-exec)\\b|\\bsocat\\b[^\\n]*\\bexec:/i,\n  },\n  {\n    id: 'credential-access',\n    severity: 'high',\n    docSeverity: 'medium',\n    codeOnly: true,\n    message: 'Reads cloud or build credentials',\n    test: /\\bAWS_SECRET_ACCESS_KEY\\b|\\bAWS_SESSION_TOKEN\\b|\\bAWS_CONTAINER_CREDENTIALS_(?:RELATIVE|FULL)_URI\\b|\\bAWS_CONTAINER_AUTHORIZATION_TOKEN(?:_FILE)?\\b|\\bCODEBUILD_[A-Z0-9_]*(?:TOKEN|CREDENTIAL|SECRET|AUTH)[A-Z0-9_]*\\b|169\\.254\\.169\\.254|169\\.254\\.170\\.2|fd00:ec2::254|\\.aws\\/credentials|\\/var\\/run\\/secrets\\b/,\n  },\n  {\n    id: 'pipe-to-shell',\n    severity: 'high',\n    docSeverity: null,\n    codeOnly: true,\n    message: 'Download piped straight into a shell',\n    test: new RegExp(String.raw`\\b(?:curl|wget)\\b[^\\n|]*\\|\\s*${SHELL}`, 'i'),\n  },\n  {\n    id: 'secret-literal',\n    severity: 'high',\n    message: 'Secret-looking literal',\n    secret: true,\n    test: /\\b(?:AKIA|ASIA)[0-9A-Z]{16}\\b|\\bgh[pousr]_[A-Za-z0-9]{36,}\\b|\\bgithub_pat_[A-Za-z0-9_]{40,}\\b|\\bxox[bap]-[A-Za-z0-9-]{10,}|-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----|\\bglpat-[A-Za-z0-9_-]{20,}\\b|\\bsk_live_[A-Za-z0-9]{16,}\\b/,\n  },\n];\n\n/** `NAME=value` / `NAME: value` / `ENV NAME value` assignments to a secret-looking name. */\nconst SECRET_ASSIGNMENT = /\\b([A-Za-z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY|ACCESS_KEY|_KEY))\\b[\"']?\\s*(?:[:=]|\\s)\\s*[\"']?([^\\s\"'`,;)]{16,})/i;\n/** A long single-token base64 or hex run (an embedded payload). */\nconst ENCODED_BLOB = /[A-Za-z0-9+/]{240,}={0,2}|\\b[0-9a-fA-F]{240,}\\b/;\n\n/** Shannon entropy of `s`, in bits per character. */\nexport function shannonEntropy(s: string): number {\n  if (!s) return 0;\n  const counts = new Map<string, number>();\n  for (const ch of s) counts.set(ch, (counts.get(ch) ?? 0) + 1);\n  let h = 0;\n  for (const n of counts.values()) {\n    const p = n / s.length;\n    h -= p * Math.log2(p);\n  }\n  return h;\n}\n\n/** Whether a secret-assignment value looks like a real credential (not a placeholder or a reference). */\nfunction looksLikeSecretValue(value: string): boolean {\n  if (/[$]|\\{\\{|<|>|\\*{3,}|x{6,}|changeme|example|placeholder|your[-_]/i.test(value)) return false;\n  return shannonEntropy(value) >= 3.5;\n}\n\nfunction isDocFile(path: string): boolean {\n  return /(^|\\/)readme(\\.[a-z]+)?$/i.test(path) || /\\.(md|markdown|rst|txt|adoc)$/i.test(path);\n}\n\nfunction mask(line: string): string {\n  return line\n    .replace(/\\b((?:AKIA|ASIA)[0-9A-Z]{4})[0-9A-Z]{12}\\b/g, '$1…')\n    .replace(/\\b(gh[pousr]_|github_pat_|xox[bap]-|glpat-|sk_live_)[A-Za-z0-9_-]+/g, '$1…')\n    .replace(SECRET_ASSIGNMENT, (m, _name: string, value: string) => m.replace(value, `${value.slice(0, 4)}…`));\n}\n\nfunction excerptOf(line: string, secret: boolean): string {\n  const t = (secret ? mask(line) : line).trim();\n  return t.length > EXCERPT_MAX ? `${t.slice(0, EXCERPT_MAX - 1)}…` : t;\n}\n\n/** Whether a decoded buffer looks binary (a NUL in its first 8 KiB). */\nfunction isBinary(bytes: Uint8Array): boolean {\n  const n = Math.min(bytes.length, 8192);\n  for (let i = 0; i < n; i++) if (bytes[i] === 0) return true;\n  return false;\n}\n\nfunction asText(content: string | Uint8Array): { text: string | null; bytes: number } {\n  if (typeof content === 'string') return { text: content.includes('\\u0000') ? null : content, bytes: Buffer.byteLength(content) };\n  if (isBinary(content)) return { text: null, bytes: content.length };\n  return { text: Buffer.from(content).toString('utf8'), bytes: content.length };\n}\n\n/**\n * Scan a plugin package's files. `files` paths are package-relative; a\n * Dockerfile is recognised by name (`Dockerfile`, `*.Dockerfile`,\n * `Dockerfile.*`). Deterministic: findings come back in file then line order.\n */\nexport function scanPluginSourceHeuristics(files: readonly HeuristicsInputFile[]): HeuristicsReport {\n  const findings: HeuristicFinding[] = [];\n  const skippedFiles: string[] = [];\n  const seen = new Set<string>();\n  let scannedFiles = 0;\n  let budget = HEURISTICS_MAX_TOTAL_BYTES;\n\n  const add = (f: HeuristicFinding): void => {\n    const key = `${f.id}|${f.path}|${f.line}`;\n    if (seen.has(key) || findings.length >= HEURISTICS_MAX_FINDINGS) return;\n    seen.add(key);\n    findings.push(f);\n  };\n\n  for (const file of files) {\n    const { text, bytes } = asText(file.content);\n    if (text === null || bytes > HEURISTICS_MAX_FILE_BYTES || bytes > budget) {\n      skippedFiles.push(file.path);\n      continue;\n    }\n    budget -= bytes;\n    scannedFiles++;\n    const doc = isDocFile(file.path);\n    const lines = text.replace(/\\r\\n?/g, '\\n').split('\\n');\n\n    lines.forEach((raw, idx) => {\n      const line = idx + 1;\n      if (ENCODED_BLOB.test(raw)) {\n        add({ id: 'encoded-blob', severity: 'medium', path: file.path, line, excerpt: excerptOf(raw, false), message: 'Long single-line encoded payload' });\n      }\n      const scan = raw.length > LINE_SCAN_MAX ? raw.slice(0, LINE_SCAN_MAX) : raw;\n      const comment = /^\\s*(#|\\/\\/)/.test(scan);\n      for (const rule of LINE_RULES) {\n        if (rule.codeOnly && comment) continue;\n        if (!rule.test.test(scan)) continue;\n        const severity = doc && rule.docSeverity !== undefined ? rule.docSeverity : rule.severity;\n        if (severity === null) continue;\n        add({ id: rule.id, severity, path: file.path, line, excerpt: excerptOf(scan, rule.secret === true), message: rule.message });\n      }\n      const assignment = SECRET_ASSIGNMENT.exec(scan);\n      if (assignment && looksLikeSecretValue(assignment[2]!)) {\n        add({\n          id: 'secret-default',\n          severity: doc ? 'medium' : 'high',\n          path: file.path,\n          line,\n          excerpt: excerptOf(scan, true),\n          message: `High-entropy value assigned to ${assignment[1]}`,\n        });\n      }\n    });\n\n    // Dockerfile RUN lines that pipe a download into a shell, continuation-joined\n    // (the line rule above only sees one physical line).\n    if (/(^|\\/)(Dockerfile(\\.[^/]+)?|[^/]+\\.Dockerfile)$/i.test(file.path)) {\n      for (const instruction of pipeInstallers(text)) {\n        const firstLine = lines.findIndex((l) => l.trim() !== '' && instruction.startsWith(l.trim().replace(/\\\\\\s*$/, '').trim()));\n        add({\n          id: 'pipe-to-shell',\n          severity: 'high',\n          path: file.path,\n          line: firstLine >= 0 ? firstLine + 1 : 1,\n          excerpt: excerptOf(instruction, false),\n          message: 'Download piped straight into a shell',\n        });\n      }\n    }\n  }\n\n  return { findings, scannedFiles, skippedFiles };\n}\n\n/** The findings that fail a gate (`high`). */\nexport function blockingHeuristics(report: Pick<HeuristicsReport, 'findings'>): HeuristicFinding[] {\n  return report.findings.filter((f) => f.severity === 'high');\n}\n"]}

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

@@ -0,0 +1,18 @@
+export interface PluginLintFinding {
+    level: 'error' | 'warning';
+    message: string;
+}
+/** Spec fields test-plugins.sh requires on every plugin. */
+export declare const PLUGIN_LINT_REQUIRED_FIELDS: readonly string[];
+/** …and on every CodeBuildStep. */
+export declare const PLUGIN_LINT_CODEBUILD_FIELDS: readonly string[];
+/** Logical Dockerfile instructions: comment lines dropped, `\` continuations joined. */
+export declare function dockerfileInstructions(content: string): string[];
+/** RUN instructions that pipe into a shell (`curl … | bash`). */
+export declare function pipeInstallers(content: string): string[];
+/** curl/wget DOWNLOADS in RUN, and `ADD <url>` without `--checksum=`. */
+export declare function rawDownloads(content: string): string[];
+/** Lint a Dockerfile against the catalog's rules. */
+export declare function lintPluginDockerfile(content: string): PluginLintFinding[];
+/** Lint the spec document (as parsed) the way test-plugins.sh does. */
+export declare function lintPluginSpec(spec: Record<string, unknown>, specText: string): PluginLintFinding[];