@pipeline-builder/pipeline-manager 4.1.14 → 4.1.16

package/dist/commands/new-plugin.js

@@ -2,128 +2,294 @@
 // SPDX-License-Identifier: Apache-2.0
 import fs from 'fs';
 import path from 'path';
+import { PLUGIN_BASE_IMAGES, PLUGIN_CATEGORIES, PLUGIN_COMPUTE_TYPES, PLUGIN_NAME_PATTERN, PLUGIN_SUMMARY_MAX, PLUGIN_TYPES, isAllowedSpdxId, validateCatalogField, } from '@pipeline-builder/api-core';
 import { Command } from 'commander';
-import YAML from 'yaml';
+import { CURATED_ICON_KEYS } from '../config/plugin-catalog-assets.js';
 import { printCommandHeader } from '../utils/command-utils.js';
 import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
-import { printInfo, printSection, printSuccess, fileExists, ensureOutputDirectory } from '../utils/output-utils.js';
-const PLUGIN_TYPES = ['CodeBuildStep', 'ShellStep', 'ManualApprovalStep'];
-const COMPUTE_TYPES = ['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE'];
-const BUILD_TYPES = ['build_image', 'prebuilt', 'metadata_only'];
+import { printInfo, printSection, printSuccess, printWarning, fileExists, ensureOutputDirectory } from '../utils/output-utils.js';
+/** `my-linter` → `My Linter`. */
+export const displayNameOf = (name) => name.split('-').filter(Boolean).map(w => w[0].toUpperCase() + w.slice(1)).join(' ');
+/** YAML double-quoted scalar (JSON strings are valid YAML). */
+const q = (s) => JSON.stringify(s);
+/** Validate the flags into a scaffold request (throws ValidationError). */
+export function resolveScaffoldInput(options, now = new Date()) {
+    const name = options.name ?? '';
+    if (!name || !PLUGIN_NAME_PATTERN.test(name) || name.length > 64) {
+        throw new ValidationError('--name must be 1-64 lowercase letters, digits and hyphens', 'name', name);
+    }
+    const category = options.category ?? '';
+    if (!PLUGIN_CATEGORIES.includes(category)) {
+        throw new ValidationError(`--category must be one of: ${PLUGIN_CATEGORIES.join(', ')}`, 'category', category);
+    }
+    const base = PLUGIN_BASE_IMAGES.find(b => b.key === (options.base ?? 'plugin'));
+    if (!base)
+        throw new ValidationError(`--base must be one of: ${PLUGIN_BASE_IMAGES.map(b => b.key).join(', ')} (see --list-bases)`, 'base', options.base);
+    const pluginType = options.type ?? 'CodeBuildStep';
+    if (!PLUGIN_TYPES.includes(pluginType))
+        throw new ValidationError(`--type must be one of: ${PLUGIN_TYPES.join(', ')}`, 'type', pluginType);
+    const computeType = options.compute ?? 'SMALL';
+    if (!PLUGIN_COMPUTE_TYPES.includes(computeType))
+        throw new ValidationError(`--compute must be one of: ${PLUGIN_COMPUTE_TYPES.join(', ')}`, 'compute', computeType);
+    const license = options.license ?? 'Apache-2.0';
+    if (!isAllowedSpdxId(license))
+        throw new ValidationError('--license must be a supported SPDX identifier (e.g. Apache-2.0, MIT)', 'license', license);
+    const icon = options.icon && options.icon !== 'none' ? options.icon : null;
+    if (icon !== null && !CURATED_ICON_KEYS.includes(icon)) {
+        throw new ValidationError(`--icon must be a curated key (${CURATED_ICON_KEYS.join(', ')}) or none`, 'icon', icon);
+    }
+    const display = displayNameOf(name);
+    const summary = options.summary ?? `${display} as a pipeline step.`;
+    const description = options.description
+        ?? `${display} runs as a CodeBuild step in your pipeline. Replace this with what the plugin checks or builds, what it reads from the workspace and what it writes.`;
+    for (const [field, value] of [['summary', summary], ['description', description]]) {
+        const checked = validateCatalogField(field, value);
+        if (!checked.ok)
+            throw new ValidationError(`--${field} ${checked.error}${field === 'summary' ? ` (max ${PLUGIN_SUMMARY_MAX})` : ''}`, field, value);
+    }
+    return {
+        name,
+        category,
+        base,
+        summary,
+        description,
+        license,
+        icon,
+        pluginType,
+        computeType,
+        author: options.author ?? `The ${name} authors`,
+        year: now.getUTCFullYear(),
+    };
+}
+const MIT_TEXT = (year, author) => `MIT License
+
+Copyright (c) ${year} ${author}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+/** LICENSE: the MIT text in full, else the SPDX notice (Apache-2.0's own recommended form). */
+export function licenseText(input) {
+    if (input.license === 'MIT')
+        return MIT_TEXT(input.year, input.author);
+    if (input.license === 'Apache-2.0') {
+        return `Copyright ${input.year} ${input.author}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+SPDX-License-Identifier: Apache-2.0
+`;
+    }
+    return `Copyright ${input.year} ${input.author}
+
+This plugin is licensed under ${input.license}.
+Full text: https://spdx.org/licenses/${input.license}.html
+
+SPDX-License-Identifier: ${input.license}
+`;
+}
+/** Keywords: the category plus the name's words (≤ 10, each ≤ 32, no duplicates). */
+export function scaffoldKeywords(name, category) {
+    return [...new Set([category, ...name.split('-')].filter(w => w.length >= 2 && w.length <= 32))].slice(0, 10);
+}
+function dockerfileText(input) {
+    const display = displayNameOf(input.name);
+    return `# ${display} — ${input.summary}
+#
+# Thin layer over ${input.base.image} (deploy/plugins/_base/${input.base.dir}:
+# ${input.base.provides}). Add ONLY this plugin's own tool, pinned. Rules
+# (deploy/plugins/README.md, enforced by test-plugins.sh and \`plugin validate\`):
+#   - every download goes through fetch-verified with a pinned version and a
+#     pinned per-architecture digest; never a rolling URL, never curl | sh;
+#   - switch to root only for the steps that need it, and end as USER 1000:1000;
+#   - a tool that ships several versions puts them under /opt/<tool>/versions
+#     with the active one symlinked from a uid-1000-owned /opt/<tool>/bin.
+
+FROM ${input.base.image}
+
+# ─── Tool install (uncomment and fill in) ───
+# Take each digest from the vendor's published checksum file.
+# USER root
+# ARG TOOL_VERSION=1.2.3
+# ARG TOOL_SHA256_AMD64=<sha256 of the linux-amd64 asset>
+# ARG TOOL_SHA256_ARM64=<sha256 of the linux-arm64 asset>
+# RUN set -eux; \\
+#     case "$(dpkg --print-architecture)" in \\
+#       amd64) arch=amd64; sum="\${TOOL_SHA256_AMD64}" ;; \\
+#       arm64) arch=arm64; sum="\${TOOL_SHA256_ARM64}" ;; \\
+#       *) echo "unsupported architecture: $(dpkg --print-architecture)" >&2; exit 1 ;; \\
+#     esac; \\
+#     fetch-verified "https://example.com/tool/v\${TOOL_VERSION}/tool-linux-\${arch}.tar.gz" "$sum" /tmp/tool.tar.gz; \\
+#     install -d /opt/tool/bin; \\
+#     tar -xzf /tmp/tool.tar.gz -C /opt/tool/bin; \\
+#     rm -f /tmp/tool.tar.gz; \\
+#     chmod -R a+rX /opt/tool
+# ENV PATH="/opt/tool/bin:\${PATH}"
+
+WORKDIR /app
+USER 1000:1000
+CMD ["bash"]
+`;
+}
+function specText(input) {
+    const out = `${input.name}-reports`;
+    const isApproval = input.pluginType === 'ManualApprovalStep';
+    const lines = [
+        `name: ${input.name}`,
+        `summary: ${q(input.summary)}`,
+        `description: ${q(input.description)}`,
+        'keywords:',
+        ...scaffoldKeywords(input.name, input.category).map(k => `  - ${k}`),
+        `category: ${input.category}`,
+        'version: 0.1.0',
+        `pluginType: ${input.pluginType}`,
+        `computeType: ${input.computeType}`,
+        `timeout: ${isApproval ? 0 : 10}`,
+        'failureBehavior: fail',
+        'secrets: []',
+    ];
+    if (!isApproval) {
+        lines.push(`primaryOutputDirectory: ${out}`, 'dockerfile: Dockerfile', 'installCommands:', `  - mkdir -p ${out}`, 'commands:', '  # Replace with the real tool invocation. run-logged (from the base image)', '  # streams output to the console AND the log, and exits with the command\'s', '  # own status, so a failure is never masked.', '  - |', '    set -e', `    echo "Running ${input.name} in $(pwd)"`, `    run-logged ${out}/${input.name}.log -- echo "${input.name} ran"`, '# Run against the built image by test-plugins.sh --build and `plugin test`.', `smokeTest: ${q(input.base.smokeTest)}`);
+    }
+    lines.push('', '# ─── Catalog metadata ───', `license: ${input.license}`, input.icon
+        ? `icon: ${input.icon}  # curated keys are for Official and Verified listings; Community listings upload an icon`
+        : '# icon: none — a Community listing uploads a raster icon or shows its monogram', 'changelog: |', '  0.1.0: Initial release.', '');
+    return lines.join('\n');
+}
+function readmeText(input, relDir) {
+    const display = displayNameOf(input.name);
+    return `# ${display}
+
+${input.description}
+
+## Use it in a pipeline
+
+\`\`\`yaml
+steps:
+  - plugin: { name: ${input.name} }
+\`\`\`
+
+${input.pluginType === 'ManualApprovalStep' ? '' : `The step writes its results to \`${input.name}-reports/\` (its primary output).
+
+`}## Develop
+
+\`\`\`bash
+pipeline-manager plugin validate --dir ${relDir}   # the server's schema + catalog report
+pipeline-manager plugin test --dir ${relDir} --workspace ./sample-app
+pipeline-manager plugin publish --dir ${relDir}    # pre-flight, accept or edit metadata, submit
+\`\`\`
+
+The image builds FROM \`${input.base.image}\`; build the bases first with
+\`deploy/bin/build-plugin-images.sh\`, or pass \`--image\` to \`plugin test\`.
+
+## License
+
+${input.license} — see [LICENSE](LICENSE).
+`;
+}
+/** Every file of a new plugin, keyed by path relative to the plugin directory. */
+export function scaffoldFiles(input, relDir = `./${input.name}`) {
+    const isApproval = input.pluginType === 'ManualApprovalStep';
+    const files = {
+        'config.yaml': isApproval
+            ? 'pluginSpec: plugin-spec.yaml\nbuildType: metadata_only\n'
+            : 'pluginSpec: plugin-spec.yaml\nbuildType: build_image\ndockerfile: Dockerfile\n',
+        'plugin-spec.yaml': specText(input),
+        'README.md': readmeText(input, relDir),
+        'LICENSE': licenseText(input),
+    };
+    if (!isApproval)
+        files.Dockerfile = dockerfileText(input);
+    return files;
+}
+/** Print the available plugin bases. */
+export function printBases() {
+    printSection('Plugin base images', 'deploy/plugins/_base');
+    for (const b of PLUGIN_BASE_IMAGES)
+        console.log(`  ${b.key.padEnd(8)} ${b.image.padEnd(28)} ${b.provides}`);
+}
 /**
- * Register the `new-plugin` command — scaffold a local plugin directory
- * (`config.yaml`, `plugin-spec.yaml`, and a starter `Dockerfile`) that
- * `validate-plugin` accepts and `upload-plugin` can package.
+ * Register `plugin new` — scaffold a plugin FROM a `pipeline-<eco>-base` image:
+ * a Dockerfile that follows the catalog rules, a spec with catalog metadata, a
+ * README, a changelog entry and a LICENSE. It passes `plugin validate` and
+ * test-plugins.sh's static checks as generated.
  *
  * Usage:
- *   pipeline-manager plugin new --name my-linter --category quality
- *   pipeline-manager plugin new --name approve --type ManualApprovalStep
+ *   pipeline-manager plugin new --list-bases
+ *   pipeline-manager plugin new --name my-linter --category quality --base node
  */
 export function newPlugin(program) {
     program
         .command('new')
-        .description('Scaffold a local plugin directory (config.yaml, plugin-spec.yaml, Dockerfile)')
-        .requiredOption('--name <name>', 'Plugin name (lowercase letters, digits, hyphens)')
-        .option('--category <category>', 'Plugin category (e.g. quality, security, language)', 'general')
+        .description('Scaffold a plugin from a pipeline-<eco>-base image (Dockerfile, spec, README, LICENSE)')
+        .option('--name <name>', 'Plugin name (lowercase letters, digits, hyphens)')
+        .option('--category <category>', `Category: ${PLUGIN_CATEGORIES.join(' | ')}`)
+        .option('--base <eco>', `Base image: ${PLUGIN_BASE_IMAGES.map(b => b.key).join(' | ')}`, 'plugin')
+        .option('--summary <text>', `Catalog one-liner (≤ ${PLUGIN_SUMMARY_MAX})`)
+        .option('--description <text>', 'Catalog description')
+        .option('--license <spdx>', 'SPDX license id', 'Apache-2.0')
+        .option('--icon <key>', 'Curated icon key (Official/Verified listings only), or none', 'none')
+        .option('--author <name>', 'Copyright holder for LICENSE')
         .option('--type <type>', `Plugin type: ${PLUGIN_TYPES.join(' | ')}`, 'CodeBuildStep')
-        .option('--compute <compute>', `Compute type: ${COMPUTE_TYPES.join(' | ')}`, 'SMALL')
-        .option('--build-type <buildType>', `Build type: ${BUILD_TYPES.join(' | ')}`, 'build_image')
+        .option('--compute <compute>', `Compute type: ${PLUGIN_COMPUTE_TYPES.join(' | ')}`, 'SMALL')
         .option('--dir <path>', 'Target directory (default ./<name>)')
         .option('--force', 'Overwrite an existing directory', false)
+        .option('--list-bases', 'List the available base images and exit', false)
         .action((options) => {
+        if (options.listBases) {
+            printBases();
+            return;
+        }
         const executionId = printCommandHeader('New Plugin');
         try {
-            const name = options.name ?? '';
-            // Canonical plugin-name pattern (matches validate-plugin, upload-plugin,
-            // and the server's NAME_PATTERN).
-            if (!/^[a-z0-9-]+$/.test(name)) {
-                throw new ValidationError('Plugin name must contain only lowercase letters, digits, and hyphens (/^[a-z0-9-]+$/)');
-            }
-            const pluginType = options.type ?? 'CodeBuildStep';
-            if (!PLUGIN_TYPES.includes(pluginType))
-                throw new ValidationError(`--type must be one of: ${PLUGIN_TYPES.join(', ')}`);
-            const computeType = options.compute ?? 'SMALL';
-            if (!COMPUTE_TYPES.includes(computeType))
-                throw new ValidationError(`--compute must be one of: ${COMPUTE_TYPES.join(', ')}`);
-            const buildType = options.buildType ?? 'build_image';
-            if (!BUILD_TYPES.includes(buildType))
-                throw new ValidationError(`--build-type must be one of: ${BUILD_TYPES.join(', ')}`);
-            const targetDir = path.resolve(options.dir ?? `./${name}`);
+            const input = resolveScaffoldInput(options);
+            const relDir = options.dir ?? `./${input.name}`;
+            const targetDir = path.resolve(relDir);
             if (fileExists(targetDir) && !options.force) {
                 throw new ValidationError(`Directory already exists: ${targetDir} (use --force to overwrite)`);
             }
             ensureOutputDirectory(targetDir);
-            const isApproval = pluginType === 'ManualApprovalStep';
-            // Dockerfile only for image builds of a real build step.
-            const needsDockerfile = buildType === 'build_image' && !isApproval;
-            // config.yaml — build manifest.
-            const config = { pluginSpec: 'plugin-spec.yaml', buildType };
-            if (needsDockerfile)
-                config.dockerfile = 'Dockerfile';
-            fs.writeFileSync(path.join(targetDir, 'config.yaml'), YAML.stringify(config), 'utf-8');
-            // plugin-spec.yaml — the PluginSpec.
-            const spec = {
-                name,
-                version: '1.0.0',
-                description: `${name} plugin`,
-                keywords: [],
-                category: options.category ?? 'general',
-                pluginType,
-                computeType,
-                timeout: isApproval ? 0 : 10,
-                failureBehavior: 'fail',
-                secrets: [],
-            };
-            if (!isApproval) {
-                spec.installCommands = ['echo "install step — add your setup commands"'];
-                spec.commands = [`echo "run step for ${name} — replace with real commands"`];
-                if (needsDockerfile)
-                    spec.dockerfile = 'Dockerfile';
-            }
-            fs.writeFileSync(path.join(targetDir, 'plugin-spec.yaml'), YAML.stringify(spec), 'utf-8');
-            // Starter Dockerfile.
-            if (needsDockerfile) {
-                const dockerfile = [
-                    `# Dockerfile for the ${name} plugin.`,
-                    '# The base image provides the toolchain your commands need — keep it minimal and pinned.',
-                    'FROM alpine:3.20',
-                    '',
-                    '# TODO: install the tools your plugin-spec commands invoke, e.g.:',
-                    '# RUN apk add --no-cache python3',
-                    '',
-                    'WORKDIR /workspace',
-                    '',
-                ].join('\n');
-                fs.writeFileSync(path.join(targetDir, 'Dockerfile'), dockerfile, 'utf-8');
-            }
-            // README.
-            const relDir = options.dir ?? `./${name}`;
-            fs.writeFileSync(path.join(targetDir, 'README.md'), [
-                `# ${name}`,
-                '',
-                `${name} plugin.`,
-                '',
-                'Validate before upload:',
-                '',
-                `    pipeline-manager plugin validate --dir ${relDir}`,
-                '',
-                'Package and upload:',
-                '',
-                `    (cd ${relDir} && zip -r ../${name}.zip .)`,
-                `    pipeline-manager plugin upload --file ${name}.zip --organization <org>`,
-                '',
-            ].join('\n'), 'utf-8');
+            const files = scaffoldFiles(input, relDir);
+            for (const [file, content] of Object.entries(files))
+                fs.writeFileSync(path.join(targetDir, file), content, 'utf-8');
+            if (input.icon)
+                printWarning('Curated icons are reserved for Official listings and Verified publishers who own the mark; a Community listing with one is refused at submit');
             printSection('Scaffolded plugin', targetDir);
-            printInfo('Created files', { files: ['config.yaml', 'plugin-spec.yaml', ...(needsDockerfile ? ['Dockerfile'] : []), 'README.md'] });
-            printSuccess('Plugin scaffold created — edit plugin-spec.yaml then run validate-plugin', { executionId, dir: targetDir });
+            printInfo('Created files', { files: Object.keys(files), base: input.base.image });
+            printSuccess('Plugin scaffold created — next: plugin validate, plugin test, plugin publish', { executionId, dir: targetDir });
         }
         catch (err) {
             handleError(err, err instanceof ValidationError ? ERROR_CODES.VALIDATION : ERROR_CODES.GENERAL, {
                 debug: program.opts().debug,
                 exit: true,
-                context: { command: 'new-plugin', executionId },
+                context: { command: 'plugin new', executionId },
             });
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new-plugin.js","sourceRoot":"","sources":["../../src/commands/new-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport fs from 'fs';\nimport path from 'path';\nimport { Command } from 'commander';\nimport YAML from 'yaml';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { printInfo, printSection, printSuccess, fileExists, ensureOutputDirectory } from '../utils/output-utils.js';\n\ninterface NewPluginOptions {\n  name?: string;\n  category?: string;\n  type?: string;\n  compute?: string;\n  buildType?: string;\n  dir?: string;\n  force?: boolean;\n}\n\nconst PLUGIN_TYPES = ['CodeBuildStep', 'ShellStep', 'ManualApprovalStep'];\nconst COMPUTE_TYPES = ['SMALL', 'MEDIUM', 'LARGE', 'X2_LARGE'];\nconst BUILD_TYPES = ['build_image', 'prebuilt', 'metadata_only'];\n\n/**\n * Register the `new-plugin` command — scaffold a local plugin directory\n * (`config.yaml`, `plugin-spec.yaml`, and a starter `Dockerfile`) that\n * `validate-plugin` accepts and `upload-plugin` can package.\n *\n * Usage:\n *   pipeline-manager plugin new --name my-linter --category quality\n *   pipeline-manager plugin new --name approve --type ManualApprovalStep\n */\nexport function newPlugin(program: Command): void {\n  program\n    .command('new')\n    .description('Scaffold a local plugin directory (config.yaml, plugin-spec.yaml, Dockerfile)')\n    .requiredOption('--name <name>', 'Plugin name (lowercase letters, digits, hyphens)')\n    .option('--category <category>', 'Plugin category (e.g. quality, security, language)', 'general')\n    .option('--type <type>', `Plugin type: ${PLUGIN_TYPES.join(' | ')}`, 'CodeBuildStep')\n    .option('--compute <compute>', `Compute type: ${COMPUTE_TYPES.join(' | ')}`, 'SMALL')\n    .option('--build-type <buildType>', `Build type: ${BUILD_TYPES.join(' | ')}`, 'build_image')\n    .option('--dir <path>', 'Target directory (default ./<name>)')\n    .option('--force', 'Overwrite an existing directory', false)\n    .action((options: NewPluginOptions) => {\n      const executionId = printCommandHeader('New Plugin');\n      try {\n        const name = options.name ?? '';\n        // Canonical plugin-name pattern (matches validate-plugin, upload-plugin,\n        // and the server's NAME_PATTERN).\n        if (!/^[a-z0-9-]+$/.test(name)) {\n          throw new ValidationError('Plugin name must contain only lowercase letters, digits, and hyphens (/^[a-z0-9-]+$/)');\n        }\n        const pluginType = options.type ?? 'CodeBuildStep';\n        if (!PLUGIN_TYPES.includes(pluginType)) throw new ValidationError(`--type must be one of: ${PLUGIN_TYPES.join(', ')}`);\n        const computeType = options.compute ?? 'SMALL';\n        if (!COMPUTE_TYPES.includes(computeType)) throw new ValidationError(`--compute must be one of: ${COMPUTE_TYPES.join(', ')}`);\n        const buildType = options.buildType ?? 'build_image';\n        if (!BUILD_TYPES.includes(buildType)) throw new ValidationError(`--build-type must be one of: ${BUILD_TYPES.join(', ')}`);\n\n        const targetDir = path.resolve(options.dir ?? `./${name}`);\n        if (fileExists(targetDir) && !options.force) {\n          throw new ValidationError(`Directory already exists: ${targetDir} (use --force to overwrite)`);\n        }\n        ensureOutputDirectory(targetDir);\n\n        const isApproval = pluginType === 'ManualApprovalStep';\n        // Dockerfile only for image builds of a real build step.\n        const needsDockerfile = buildType === 'build_image' && !isApproval;\n\n        // config.yaml — build manifest.\n        const config: Record<string, unknown> = { pluginSpec: 'plugin-spec.yaml', buildType };\n        if (needsDockerfile) config.dockerfile = 'Dockerfile';\n        fs.writeFileSync(path.join(targetDir, 'config.yaml'), YAML.stringify(config), 'utf-8');\n\n        // plugin-spec.yaml — the PluginSpec.\n        const spec: Record<string, unknown> = {\n          name,\n          version: '1.0.0',\n          description: `${name} plugin`,\n          keywords: [] as string[],\n          category: options.category ?? 'general',\n          pluginType,\n          computeType,\n          timeout: isApproval ? 0 : 10,\n          failureBehavior: 'fail',\n          secrets: [] as unknown[],\n        };\n        if (!isApproval) {\n          spec.installCommands = ['echo \"install step — add your setup commands\"'];\n          spec.commands = [`echo \"run step for ${name} — replace with real commands\"`];\n          if (needsDockerfile) spec.dockerfile = 'Dockerfile';\n        }\n        fs.writeFileSync(path.join(targetDir, 'plugin-spec.yaml'), YAML.stringify(spec), 'utf-8');\n\n        // Starter Dockerfile.\n        if (needsDockerfile) {\n          const dockerfile = [\n            `# Dockerfile for the ${name} plugin.`,\n            '# The base image provides the toolchain your commands need — keep it minimal and pinned.',\n            'FROM alpine:3.20',\n            '',\n            '# TODO: install the tools your plugin-spec commands invoke, e.g.:',\n            '# RUN apk add --no-cache python3',\n            '',\n            'WORKDIR /workspace',\n            '',\n          ].join('\\n');\n          fs.writeFileSync(path.join(targetDir, 'Dockerfile'), dockerfile, 'utf-8');\n        }\n\n        // README.\n        const relDir = options.dir ?? `./${name}`;\n        fs.writeFileSync(path.join(targetDir, 'README.md'), [\n          `# ${name}`,\n          '',\n          `${name} plugin.`,\n          '',\n          'Validate before upload:',\n          '',\n          `    pipeline-manager plugin validate --dir ${relDir}`,\n          '',\n          'Package and upload:',\n          '',\n          `    (cd ${relDir} && zip -r ../${name}.zip .)`,\n          `    pipeline-manager plugin upload --file ${name}.zip --organization <org>`,\n          '',\n        ].join('\\n'), 'utf-8');\n\n        printSection('Scaffolded plugin', targetDir);\n        printInfo('Created files', { files: ['config.yaml', 'plugin-spec.yaml', ...(needsDockerfile ? ['Dockerfile'] : []), 'README.md'] });\n        printSuccess('Plugin scaffold created — edit plugin-spec.yaml then run validate-plugin', { executionId, dir: targetDir });\n      } catch (err) {\n        handleError(err, err instanceof ValidationError ? ERROR_CODES.VALIDATION : ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'new-plugin', executionId },\n        });\n      }\n    });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new-plugin.js","sourceRoot":"","sources":["../../src/commands/new-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport fs from 'fs';\nimport path from 'path';\nimport {\n  PLUGIN_BASE_IMAGES, PLUGIN_CATEGORIES, PLUGIN_COMPUTE_TYPES, PLUGIN_NAME_PATTERN, PLUGIN_SUMMARY_MAX, PLUGIN_TYPES,\n  isAllowedSpdxId, validateCatalogField, type PluginBaseImage,\n} from '@pipeline-builder/api-core';\nimport { Command } from 'commander';\nimport { CURATED_ICON_KEYS } from '../config/plugin-catalog-assets.js';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { printInfo, printSection, printSuccess, printWarning, fileExists, ensureOutputDirectory } from '../utils/output-utils.js';\n\nexport interface NewPluginOptions {\n  name?: string;\n  category?: string;\n  base?: string;\n  summary?: string;\n  description?: string;\n  license?: string;\n  icon?: string;\n  author?: string;\n  type?: string;\n  compute?: string;\n  dir?: string;\n  force?: boolean;\n  listBases?: boolean;\n}\n\n/** A validated scaffold request. */\nexport interface ScaffoldInput {\n  name: string;\n  category: string;\n  base: PluginBaseImage;\n  summary: string;\n  description: string;\n  license: string;\n  icon: string | null;\n  author: string;\n  pluginType: string;\n  computeType: string;\n  year: number;\n}\n\n/** `my-linter` → `My Linter`. */\nexport const displayNameOf = (name: string): string =>\n  name.split('-').filter(Boolean).map(w => w[0]!.toUpperCase() + w.slice(1)).join(' ');\n\n/** YAML double-quoted scalar (JSON strings are valid YAML). */\nconst q = (s: string): string => JSON.stringify(s);\n\n/** Validate the flags into a scaffold request (throws ValidationError). */\nexport function resolveScaffoldInput(options: NewPluginOptions, now = new Date()): ScaffoldInput {\n  const name = options.name ?? '';\n  if (!name || !PLUGIN_NAME_PATTERN.test(name) || name.length > 64) {\n    throw new ValidationError('--name must be 1-64 lowercase letters, digits and hyphens', 'name', name);\n  }\n  const category = options.category ?? '';\n  if (!(PLUGIN_CATEGORIES as readonly string[]).includes(category)) {\n    throw new ValidationError(`--category must be one of: ${PLUGIN_CATEGORIES.join(', ')}`, 'category', category);\n  }\n  const base = PLUGIN_BASE_IMAGES.find(b => b.key === (options.base ?? 'plugin'));\n  if (!base) throw new ValidationError(`--base must be one of: ${PLUGIN_BASE_IMAGES.map(b => b.key).join(', ')} (see --list-bases)`, 'base', options.base);\n  const pluginType = options.type ?? 'CodeBuildStep';\n  if (!(PLUGIN_TYPES as readonly string[]).includes(pluginType)) throw new ValidationError(`--type must be one of: ${PLUGIN_TYPES.join(', ')}`, 'type', pluginType);\n  const computeType = options.compute ?? 'SMALL';\n  if (!(PLUGIN_COMPUTE_TYPES as readonly string[]).includes(computeType)) throw new ValidationError(`--compute must be one of: ${PLUGIN_COMPUTE_TYPES.join(', ')}`, 'compute', computeType);\n  const license = options.license ?? 'Apache-2.0';\n  if (!isAllowedSpdxId(license)) throw new ValidationError('--license must be a supported SPDX identifier (e.g. Apache-2.0, MIT)', 'license', license);\n  const icon = options.icon && options.icon !== 'none' ? options.icon : null;\n  if (icon !== null && !CURATED_ICON_KEYS.includes(icon)) {\n    throw new ValidationError(`--icon must be a curated key (${CURATED_ICON_KEYS.join(', ')}) or none`, 'icon', icon);\n  }\n\n  const display = displayNameOf(name);\n  const summary = options.summary ?? `${display} as a pipeline step.`;\n  const description = options.description\n    ?? `${display} runs as a CodeBuild step in your pipeline. Replace this with what the plugin checks or builds, what it reads from the workspace and what it writes.`;\n  for (const [field, value] of [['summary', summary], ['description', description]] as const) {\n    const checked = validateCatalogField(field, value);\n    if (!checked.ok) throw new ValidationError(`--${field} ${checked.error}${field === 'summary' ? ` (max ${PLUGIN_SUMMARY_MAX})` : ''}`, field, value);\n  }\n  return {\n    name,\n    category,\n    base,\n    summary,\n    description,\n    license,\n    icon,\n    pluginType,\n    computeType,\n    author: options.author ?? `The ${name} authors`,\n    year: now.getUTCFullYear(),\n  };\n}\n\nconst MIT_TEXT = (year: number, author: string): string => `MIT License\n\nCopyright (c) ${year} ${author}\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n`;\n\n/** LICENSE: the MIT text in full, else the SPDX notice (Apache-2.0's own recommended form). */\nexport function licenseText(input: Pick<ScaffoldInput, 'license' | 'year' | 'author'>): string {\n  if (input.license === 'MIT') return MIT_TEXT(input.year, input.author);\n  if (input.license === 'Apache-2.0') {\n    return `Copyright ${input.year} ${input.author}\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\nSPDX-License-Identifier: Apache-2.0\n`;\n  }\n  return `Copyright ${input.year} ${input.author}\n\nThis plugin is licensed under ${input.license}.\nFull text: https://spdx.org/licenses/${input.license}.html\n\nSPDX-License-Identifier: ${input.license}\n`;\n}\n\n/** Keywords: the category plus the name's words (≤ 10, each ≤ 32, no duplicates). */\nexport function scaffoldKeywords(name: string, category: string): string[] {\n  return [...new Set([category, ...name.split('-')].filter(w => w.length >= 2 && w.length <= 32))].slice(0, 10);\n}\n\nfunction dockerfileText(input: ScaffoldInput): string {\n  const display = displayNameOf(input.name);\n  return `# ${display} — ${input.summary}\n#\n# Thin layer over ${input.base.image} (deploy/plugins/_base/${input.base.dir}:\n# ${input.base.provides}). Add ONLY this plugin's own tool, pinned. Rules\n# (deploy/plugins/README.md, enforced by test-plugins.sh and \\`plugin validate\\`):\n#   - every download goes through fetch-verified with a pinned version and a\n#     pinned per-architecture digest; never a rolling URL, never curl | sh;\n#   - switch to root only for the steps that need it, and end as USER 1000:1000;\n#   - a tool that ships several versions puts them under /opt/<tool>/versions\n#     with the active one symlinked from a uid-1000-owned /opt/<tool>/bin.\n\nFROM ${input.base.image}\n\n# ─── Tool install (uncomment and fill in) ───\n# Take each digest from the vendor's published checksum file.\n# USER root\n# ARG TOOL_VERSION=1.2.3\n# ARG TOOL_SHA256_AMD64=<sha256 of the linux-amd64 asset>\n# ARG TOOL_SHA256_ARM64=<sha256 of the linux-arm64 asset>\n# RUN set -eux; \\\\\n#     case \"$(dpkg --print-architecture)\" in \\\\\n#       amd64) arch=amd64; sum=\"\\${TOOL_SHA256_AMD64}\" ;; \\\\\n#       arm64) arch=arm64; sum=\"\\${TOOL_SHA256_ARM64}\" ;; \\\\\n#       *) echo \"unsupported architecture: $(dpkg --print-architecture)\" >&2; exit 1 ;; \\\\\n#     esac; \\\\\n#     fetch-verified \"https://example.com/tool/v\\${TOOL_VERSION}/tool-linux-\\${arch}.tar.gz\" \"$sum\" /tmp/tool.tar.gz; \\\\\n#     install -d /opt/tool/bin; \\\\\n#     tar -xzf /tmp/tool.tar.gz -C /opt/tool/bin; \\\\\n#     rm -f /tmp/tool.tar.gz; \\\\\n#     chmod -R a+rX /opt/tool\n# ENV PATH=\"/opt/tool/bin:\\${PATH}\"\n\nWORKDIR /app\nUSER 1000:1000\nCMD [\"bash\"]\n`;\n}\n\nfunction specText(input: ScaffoldInput): string {\n  const out = `${input.name}-reports`;\n  const isApproval = input.pluginType === 'ManualApprovalStep';\n  const lines = [\n    `name: ${input.name}`,\n    `summary: ${q(input.summary)}`,\n    `description: ${q(input.description)}`,\n    'keywords:',\n    ...scaffoldKeywords(input.name, input.category).map(k => `  - ${k}`),\n    `category: ${input.category}`,\n    'version: 0.1.0',\n    `pluginType: ${input.pluginType}`,\n    `computeType: ${input.computeType}`,\n    `timeout: ${isApproval ? 0 : 10}`,\n    'failureBehavior: fail',\n    'secrets: []',\n  ];\n  if (!isApproval) {\n    lines.push(\n      `primaryOutputDirectory: ${out}`,\n      'dockerfile: Dockerfile',\n      'installCommands:',\n      `  - mkdir -p ${out}`,\n      'commands:',\n      '  # Replace with the real tool invocation. run-logged (from the base image)',\n      '  # streams output to the console AND the log, and exits with the command\\'s',\n      '  # own status, so a failure is never masked.',\n      '  - |',\n      '    set -e',\n      `    echo \"Running ${input.name} in $(pwd)\"`,\n      `    run-logged ${out}/${input.name}.log -- echo \"${input.name} ran\"`,\n      '# Run against the built image by test-plugins.sh --build and `plugin test`.',\n      `smokeTest: ${q(input.base.smokeTest)}`,\n    );\n  }\n  lines.push(\n    '',\n    '# ─── Catalog metadata ───',\n    `license: ${input.license}`,\n    input.icon\n      ? `icon: ${input.icon}  # curated keys are for Official and Verified listings; Community listings upload an icon`\n      : '# icon: none — a Community listing uploads a raster icon or shows its monogram',\n    'changelog: |',\n    '  0.1.0: Initial release.',\n    '',\n  );\n  return lines.join('\\n');\n}\n\nfunction readmeText(input: ScaffoldInput, relDir: string): string {\n  const display = displayNameOf(input.name);\n  return `# ${display}\n\n${input.description}\n\n## Use it in a pipeline\n\n\\`\\`\\`yaml\nsteps:\n  - plugin: { name: ${input.name} }\n\\`\\`\\`\n\n${input.pluginType === 'ManualApprovalStep' ? '' : `The step writes its results to \\`${input.name}-reports/\\` (its primary output).\n\n`}## Develop\n\n\\`\\`\\`bash\npipeline-manager plugin validate --dir ${relDir}   # the server's schema + catalog report\npipeline-manager plugin test --dir ${relDir} --workspace ./sample-app\npipeline-manager plugin publish --dir ${relDir}    # pre-flight, accept or edit metadata, submit\n\\`\\`\\`\n\nThe image builds FROM \\`${input.base.image}\\`; build the bases first with\n\\`deploy/bin/build-plugin-images.sh\\`, or pass \\`--image\\` to \\`plugin test\\`.\n\n## License\n\n${input.license} — see [LICENSE](LICENSE).\n`;\n}\n\n/** Every file of a new plugin, keyed by path relative to the plugin directory. */\nexport function scaffoldFiles(input: ScaffoldInput, relDir = `./${input.name}`): Record<string, string> {\n  const isApproval = input.pluginType === 'ManualApprovalStep';\n  const files: Record<string, string> = {\n    'config.yaml': isApproval\n      ? 'pluginSpec: plugin-spec.yaml\\nbuildType: metadata_only\\n'\n      : 'pluginSpec: plugin-spec.yaml\\nbuildType: build_image\\ndockerfile: Dockerfile\\n',\n    'plugin-spec.yaml': specText(input),\n    'README.md': readmeText(input, relDir),\n    'LICENSE': licenseText(input),\n  };\n  if (!isApproval) files.Dockerfile = dockerfileText(input);\n  return files;\n}\n\n/** Print the available plugin bases. */\nexport function printBases(): void {\n  printSection('Plugin base images', 'deploy/plugins/_base');\n  for (const b of PLUGIN_BASE_IMAGES) console.log(`  ${b.key.padEnd(8)} ${b.image.padEnd(28)} ${b.provides}`);\n}\n\n/**\n * Register `plugin new` — scaffold a plugin FROM a `pipeline-<eco>-base` image:\n * a Dockerfile that follows the catalog rules, a spec with catalog metadata, a\n * README, a changelog entry and a LICENSE. It passes `plugin validate` and\n * test-plugins.sh's static checks as generated.\n *\n * Usage:\n *   pipeline-manager plugin new --list-bases\n *   pipeline-manager plugin new --name my-linter --category quality --base node\n */\nexport function newPlugin(program: Command): void {\n  program\n    .command('new')\n    .description('Scaffold a plugin from a pipeline-<eco>-base image (Dockerfile, spec, README, LICENSE)')\n    .option('--name <name>', 'Plugin name (lowercase letters, digits, hyphens)')\n    .option('--category <category>', `Category: ${PLUGIN_CATEGORIES.join(' | ')}`)\n    .option('--base <eco>', `Base image: ${PLUGIN_BASE_IMAGES.map(b => b.key).join(' | ')}`, 'plugin')\n    .option('--summary <text>', `Catalog one-liner (≤ ${PLUGIN_SUMMARY_MAX})`)\n    .option('--description <text>', 'Catalog description')\n    .option('--license <spdx>', 'SPDX license id', 'Apache-2.0')\n    .option('--icon <key>', 'Curated icon key (Official/Verified listings only), or none', 'none')\n    .option('--author <name>', 'Copyright holder for LICENSE')\n    .option('--type <type>', `Plugin type: ${PLUGIN_TYPES.join(' | ')}`, 'CodeBuildStep')\n    .option('--compute <compute>', `Compute type: ${PLUGIN_COMPUTE_TYPES.join(' | ')}`, 'SMALL')\n    .option('--dir <path>', 'Target directory (default ./<name>)')\n    .option('--force', 'Overwrite an existing directory', false)\n    .option('--list-bases', 'List the available base images and exit', false)\n    .action((options: NewPluginOptions) => {\n      if (options.listBases) {\n        printBases();\n        return;\n      }\n      const executionId = printCommandHeader('New Plugin');\n      try {\n        const input = resolveScaffoldInput(options);\n        const relDir = options.dir ?? `./${input.name}`;\n        const targetDir = path.resolve(relDir);\n        if (fileExists(targetDir) && !options.force) {\n          throw new ValidationError(`Directory already exists: ${targetDir} (use --force to overwrite)`);\n        }\n        ensureOutputDirectory(targetDir);\n        const files = scaffoldFiles(input, relDir);\n        for (const [file, content] of Object.entries(files)) fs.writeFileSync(path.join(targetDir, file), content, 'utf-8');\n\n        if (input.icon) printWarning('Curated icons are reserved for Official listings and Verified publishers who own the mark; a Community listing with one is refused at submit');\n        printSection('Scaffolded plugin', targetDir);\n        printInfo('Created files', { files: Object.keys(files), base: input.base.image });\n        printSuccess('Plugin scaffold created — next: plugin validate, plugin test, plugin publish', { executionId, dir: targetDir });\n      } catch (err) {\n        handleError(err, err instanceof ValidationError ? ERROR_CODES.VALIDATION : ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'plugin new', executionId },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/plugin-lifecycle.d.ts

@@ -0,0 +1,29 @@
+import { Command } from 'commander';
+/** Server cap on a deprecation message / yank reason. */
+export declare const LIFECYCLE_TEXT_MAX = 500;
+/**
+ * Registers `plugin deprecate`: mark a version deprecated (or clear it with
+ * `--undo`). A deprecated version keeps resolving, but synth prints a warning,
+ * AI selection stops offering it, and the org approvers of every org whose
+ * pipelines use it are notified.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager plugin deprecate --id <plugin-id> --message "Use 2.x"
+ * pipeline-manager plugin deprecate --id <plugin-id> --undo
+ * ```
+ */
+export declare function deprecatePlugin(program: Command): void;
+/**
+ * Registers `plugin yank`: stop a version resolving for new synths. Ranges,
+ * `latest` and the default skip it; an exact pin still resolves, with a warning
+ * carrying the reason. Yanking the default promotes the next version. A version
+ * published to the ecosystem is refused (409) — request the yank there.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager plugin yank --id <plugin-id> --reason "Leaks tokens in logs; use 1.2.1"
+ * ```
+ */
+export declare function yankPlugin(program: Command): void;
+//# sourceMappingURL=plugin-lifecycle.d.ts.map

package/dist/commands/plugin-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-lifecycle.d.ts","sourceRoot":"","sources":["../../src/commands/plugin-lifecycle.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAmCtC;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6CtD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0CjD"}