@pipeline-builder/pipeline-manager 4.1.14 → 4.1.16

package/dist/commands/test-plugin.js

@@ -0,0 +1,285 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { STEP_BOOTSTRAP_CMD, extractMetadataEnv, resolveFailureBehavior, resolvePluginTemplates, wrapCommandsForFailureBehavior, } from '@pipeline-builder/pipeline-core';
+import { Command } from 'commander';
+import { printCommandHeader } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
+import { printError, printInfo, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { buildPluginImage, hasTool, imageUser, isRootUser, localImageTag, removeImage, spawnExec, } from '../utils/plugin-docker.js';
+import { packageProblems, readPluginPackage } from '../utils/plugin-package.js';
+/** Mount point of the sample workspace inside the container (the step's source dir). */
+export const CONTAINER_WORKSPACE = '/workspace';
+/** A plugin run that failed: the step would be red in CodeBuild. */
+export class PluginTestFailure extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PluginTestFailure';
+    }
+}
+/** `KEY=VALUE` flags → a record (the value may itself contain `=`). */
+export function parseKeyValues(pairs, flag) {
+    const out = {};
+    for (const pair of pairs ?? []) {
+        const eq = pair.indexOf('=');
+        if (eq <= 0)
+            throw new ValidationError(`${flag} expects KEY=VALUE (got "${pair}")`, flag, pair);
+        out[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    return out;
+}
+const collect = (value, previous = []) => [...previous, value];
+/**
+ * Resolve the spec the way the pipeline step does: `{{ … }}` templates against
+ * the given pipeline metadata/vars, env = spec env ← non-namespaced metadata ←
+ * `--env`, the step's WORKDIR bootstrap, and the build commands wrapped for the
+ * effective failureBehavior (a security-category plugin is always `fail`).
+ */
+export function planPluginTest(spec, flags, hostEnv = process.env) {
+    const metadata = { ...(spec.metadata ?? {}), ...(flags.metadata ?? {}) };
+    let resolved;
+    try {
+        resolved = resolvePluginTemplates(spec, {
+            pipeline: {
+                projectName: 'plugin-test',
+                project: 'plugin-test',
+                orgId: 'local',
+                organization: 'local',
+                pipelineName: 'plugin-test',
+                metadata,
+                vars: flags.vars ?? {},
+            },
+        });
+    }
+    catch (err) {
+        throw new PluginTestFailure(`${err.message} — supply the value with --metadata KEY=VALUE or --var KEY=VALUE`);
+    }
+    const strings = (v) => (Array.isArray(v) ? v.filter((c) => typeof c === 'string') : []);
+    const env = {
+        ...(resolved.env ?? {}),
+        ...extractMetadataEnv(metadata),
+        ...(flags.env ?? {}),
+    };
+    const secrets = Array.isArray(spec.secrets) ? spec.secrets : [];
+    const missingRequired = secrets.filter(s => s.required && !hostEnv[s.name]).map(s => s.name);
+    if (missingRequired.length) {
+        throw new PluginTestFailure(`Required secret(s) not set in your environment: ${missingRequired.join(', ')} — export them before running plugin test`);
+    }
+    const secretNames = secrets.filter(s => hostEnv[s.name]).map(s => s.name);
+    for (const name of secretNames)
+        delete env[name];
+    const failureBehavior = resolveFailureBehavior(typeof spec.category === 'string' ? spec.category : undefined, spec.failureBehavior);
+    const script = (commands) => ['set -e', STEP_BOOTSTRAP_CMD, ...commands].join('\n');
+    const timeout = typeof spec.timeout === 'number' && spec.timeout > 0 ? spec.timeout * 60_000 : undefined;
+    return {
+        name: String(spec.name),
+        version: String(spec.version),
+        failureBehavior,
+        env,
+        secretNames,
+        missingOptionalSecrets: secrets.filter(s => !s.required && !hostEnv[s.name]).map(s => s.name),
+        installScript: script(strings(resolved.installCommands)),
+        buildScript: script(wrapCommandsForFailureBehavior(strings(resolved.commands), failureBehavior)),
+        primaryOutputDirectory: typeof spec.primaryOutputDirectory === 'string' && spec.primaryOutputDirectory ? spec.primaryOutputDirectory : undefined,
+        smokeTest: typeof spec.smokeTest === 'string' && spec.smokeTest.trim() ? spec.smokeTest : undefined,
+        timeoutMs: timeout,
+    };
+}
+/** `docker run` arguments for one phase (secret VALUES never appear here). */
+export function dockerRunArgs(image, workspace, plan, script) {
+    return [
+        'run', '--rm',
+        '-v', `${workspace}:${CONTAINER_WORKSPACE}`, '-w', CONTAINER_WORKSPACE,
+        ...Object.entries(plan.env).flatMap(([k, v]) => ['-e', `${k}=${v}`]),
+        ...plan.secretNames.flatMap(name => ['-e', name]),
+        // CodeBuild runs a step's commands under /bin/sh, so the test does too.
+        '--entrypoint', '/bin/sh',
+        image, '-c', script,
+    ];
+}
+/** Copy the sample workspace to a scratch dir the container's uid 1000 can write. */
+export function prepareWorkspace(source) {
+    const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'pipeline-manager-plugin-test-'));
+    if (source) {
+        const src = path.resolve(source);
+        if (!fs.existsSync(src) || !fs.statSync(src).isDirectory())
+            throw new ValidationError(`--workspace is not a directory: ${src}`, 'workspace', src);
+        fs.cpSync(src, ws, { recursive: true });
+    }
+    // The container runs as the image's user (uid 1000), not the host user.
+    // Executable bits are kept (a `gradlew`), symlinks are left alone (never
+    // chmod through a link to something outside the scratch dir).
+    const open = (p) => {
+        const st = fs.lstatSync(p);
+        if (st.isSymbolicLink())
+            return;
+        const ownerExecutable = Math.floor((st.mode % 0o1000) / 0o100) % 2 === 1;
+        fs.chmodSync(p, st.isDirectory() || ownerExecutable ? 0o777 : 0o666);
+        if (st.isDirectory())
+            for (const e of fs.readdirSync(p))
+                open(path.join(p, e));
+    };
+    open(ws);
+    return ws;
+}
+/** Where the step's primary output lands on the host, honouring a relative WORKDIR. */
+export function outputPath(workspace, plan) {
+    if (!plan.primaryOutputDirectory)
+        return null;
+    const workdir = plan.env.WORKDIR ?? './';
+    const base = workdir.startsWith('/')
+        ? (workdir.startsWith(CONTAINER_WORKSPACE) ? path.join(workspace, path.relative(CONTAINER_WORKSPACE, workdir)) : null)
+        : path.join(workspace, workdir);
+    return base === null ? null : path.join(base, plan.primaryOutputDirectory);
+}
+/**
+ * Build (or take) the image, then run the plugin as its CodeBuild step would:
+ * install phase, build phase (failureBehavior applied), the primary output
+ * check, then the spec's smokeTest. Any failure throws — a step that can't run
+ * or that fails is red, never green.
+ */
+export async function runPluginTest(options, exec = spawnExec) {
+    const pkg = readPluginPackage(options.dir);
+    const problems = await packageProblems(pkg);
+    if (problems.length) {
+        for (const p of problems)
+            printError(`  • ${p}`);
+        throw new ValidationError(`The plugin has ${problems.length} validation problem(s); run "plugin validate" and fix them first`);
+    }
+    const spec = pkg.spec;
+    if (spec.pluginType === 'ManualApprovalStep') {
+        throw new ValidationError('A ManualApprovalStep runs no commands, so there is nothing to test');
+    }
+    if (!hasTool(exec, 'docker'))
+        throw new PluginTestFailure('docker is not available — plugin test runs the plugin in its image');
+    const plan = planPluginTest(spec, {
+        env: parseKeyValues(options.env, '--env'),
+        metadata: parseKeyValues(options.metadata, '--metadata'),
+        vars: parseKeyValues(options.var, '--var'),
+    });
+    const workspace = prepareWorkspace(options.workspace);
+    let image = options.image;
+    let built = null;
+    try {
+        if (!image) {
+            if (pkg.buildType === 'build_image') {
+                built = localImageTag(plan.name, plan.version);
+                printSection('Building image', built);
+                const buildArgs = spec.buildArgs ?? {};
+                const error = buildPluginImage(exec, { dir: pkg.dir, dockerfile: path.join(pkg.dir, pkg.dockerfileName), tag: built, buildArgs });
+                if (error)
+                    throw new PluginTestFailure(error);
+                image = built;
+            }
+            else if (pkg.buildType === 'prebuilt') {
+                const r = exec('docker', ['load', '-i', path.join(pkg.dir, 'image.tar')]);
+                const loaded = /Loaded image(?: ID)?: (\S+)/.exec(r.stdout)?.[1];
+                if (r.status !== 0 || !loaded)
+                    throw new PluginTestFailure(`docker load image.tar failed: ${(r.stderr || r.stdout).trim()}`);
+                image = loaded;
+            }
+            else {
+                throw new ValidationError('A metadata_only plugin has no image of its own; pass the image it runs in with --image');
+            }
+        }
+        if (!image)
+            throw new PluginTestFailure('No image to run');
+        const user = imageUser(exec, image);
+        if ('error' in user)
+            throw new PluginTestFailure(user.error);
+        if (isRootUser(user.user)) {
+            throw new PluginTestFailure(`The image runs as root (USER '${user.user || '(unset)'}'); end the Dockerfile with \`USER 1000:1000\``);
+        }
+        printInfo('Running plugin', {
+            image,
+            runsAs: user.user,
+            workspace,
+            failureBehavior: plan.failureBehavior,
+            env: Object.keys(plan.env),
+            secrets: plan.secretNames,
+        });
+        if (plan.missingOptionalSecrets.length)
+            printWarning('Optional secrets not set (the step runs without them)', { secrets: plan.missingOptionalSecrets });
+        for (const [phase, script] of [['install', plan.installScript], ['build', plan.buildScript]]) {
+            printSection(`Phase: ${phase}`);
+            const r = exec('docker', dockerRunArgs(image, workspace, plan, script), { inherit: true, timeoutMs: plan.timeoutMs });
+            if (r.error)
+                throw new PluginTestFailure(`${phase} phase did not complete: ${r.error.message}`);
+            if (r.status !== 0)
+                throw new PluginTestFailure(`${phase} phase failed (exit ${r.status})`);
+        }
+        let outputFiles = null;
+        const out = outputPath(workspace, plan);
+        if (plan.primaryOutputDirectory && out === null) {
+            printWarning('WORKDIR is outside the workspace; primaryOutputDirectory cannot be checked on the host');
+        }
+        else if (out) {
+            if (!fs.existsSync(out) || !fs.statSync(out).isDirectory()) {
+                throw new PluginTestFailure(`primaryOutputDirectory '${plan.primaryOutputDirectory}' was not created`);
+            }
+            outputFiles = fs.readdirSync(out).length;
+            if (outputFiles === 0)
+                throw new PluginTestFailure(`primaryOutputDirectory '${plan.primaryOutputDirectory}' is empty`);
+            printSuccess(`primaryOutputDirectory '${plan.primaryOutputDirectory}' has ${outputFiles} entr${outputFiles === 1 ? 'y' : 'ies'}`);
+        }
+        else {
+            printWarning('The spec declares no primaryOutputDirectory; no output to check');
+        }
+        if (plan.smokeTest) {
+            printSection('Smoke test', plan.smokeTest);
+            const r = exec('docker', ['run', '--rm', '--entrypoint', '/bin/bash', image, '-c', plan.smokeTest], { inherit: true });
+            if (r.error || r.status !== 0)
+                throw new PluginTestFailure(`smokeTest failed: ${plan.smokeTest}`);
+        }
+        else {
+            printWarning('The spec declares no smokeTest');
+        }
+        return { outputFiles };
+    }
+    finally {
+        if (options.keep)
+            printInfo('Workspace kept', { workspace });
+        else
+            fs.rmSync(workspace, { recursive: true, force: true });
+        if (built && !options.keep)
+            removeImage(exec, built);
+    }
+}
+/**
+ * Register `plugin test` — run a plugin's install + build commands locally in
+ * its image against a sample workspace, check its primary output, and run its
+ * smokeTest. Exits non-zero on any failure.
+ *
+ * Usage:
+ *   pipeline-manager plugin test --dir ./my-linter --workspace ./sample-app
+ *   pipeline-manager plugin test --dir ./my-linter --image my-linter:dev --metadata STAGE=dev
+ */
+export function testPlugin(program) {
+    program
+        .command('test')
+        .description('Run a plugin\'s install + build commands locally in its image against a sample workspace')
+        .option('--dir <path>', 'Plugin directory', '.')
+        .option('--image <ref>', 'Use this image instead of building the plugin\'s Dockerfile')
+        .option('--workspace <path>', 'Sample workspace copied in as the step\'s source (default: empty)')
+        .option('--env <KEY=VALUE>', 'Extra environment variable (repeatable)', collect)
+        .option('--metadata <KEY=VALUE>', 'Pipeline metadata value (repeatable; also exported as env, as in the pipeline)', collect)
+        .option('--var <KEY=VALUE>', 'Pipeline var for {{ pipeline.vars.* }} (repeatable)', collect)
+        .option('--keep', 'Keep the scratch workspace and built image for inspection', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('Test Plugin');
+        try {
+            const result = await runPluginTest(options);
+            printSuccess('Plugin test passed', { executionId, outputEntries: result.outputFiles });
+        }
+        catch (err) {
+            handleError(err, err instanceof ValidationError ? ERROR_CODES.VALIDATION : ERROR_CODES.GENERAL, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'plugin test', executionId },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-plugin.js","sourceRoot":"","sources":["../../src/commands/test-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 os from 'os';\nimport path from 'path';\nimport {\n  STEP_BOOTSTRAP_CMD, extractMetadataEnv, resolveFailureBehavior, resolvePluginTemplates, wrapCommandsForFailureBehavior,\n} from '@pipeline-builder/pipeline-core';\nimport { Command } from 'commander';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { printError, printInfo, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport {\n  buildPluginImage, hasTool, imageUser, isRootUser, localImageTag, removeImage, spawnExec, type Exec,\n} from '../utils/plugin-docker.js';\nimport { packageProblems, readPluginPackage } from '../utils/plugin-package.js';\n\n/** Mount point of the sample workspace inside the container (the step's source dir). */\nexport const CONTAINER_WORKSPACE = '/workspace';\n\nexport interface TestPluginOptions {\n  dir: string;\n  image?: string;\n  workspace?: string;\n  env?: string[];\n  metadata?: string[];\n  var?: string[];\n  keep?: boolean;\n}\n\n/** A plugin run that failed: the step would be red in CodeBuild. */\nexport class PluginTestFailure extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'PluginTestFailure';\n  }\n}\n\n/** `KEY=VALUE` flags → a record (the value may itself contain `=`). */\nexport function parseKeyValues(pairs: string[] | undefined, flag: string): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const pair of pairs ?? []) {\n    const eq = pair.indexOf('=');\n    if (eq <= 0) throw new ValidationError(`${flag} expects KEY=VALUE (got \"${pair}\")`, flag, pair);\n    out[pair.slice(0, eq)] = pair.slice(eq + 1);\n  }\n  return out;\n}\n\nconst collect = (value: string, previous: string[] = []): string[] => [...previous, value];\n\n/** What a run needs, resolved from the spec + flags (no side effects). */\nexport interface TestPlan {\n  name: string;\n  version: string;\n  failureBehavior: 'fail' | 'warn' | 'ignore';\n  /** Plain env passed as `-e KEY=VALUE`. */\n  env: Record<string, string>;\n  /** Secret NAMES passed as `-e NAME` (docker reads the value from this process's env). */\n  secretNames: string[];\n  missingOptionalSecrets: string[];\n  installScript: string;\n  buildScript: string;\n  primaryOutputDirectory: string | undefined;\n  smokeTest: string | undefined;\n  timeoutMs: number | undefined;\n}\n\n/**\n * Resolve the spec the way the pipeline step does: `{{ … }}` templates against\n * the given pipeline metadata/vars, env = spec env ← non-namespaced metadata ←\n * `--env`, the step's WORKDIR bootstrap, and the build commands wrapped for the\n * effective failureBehavior (a security-category plugin is always `fail`).\n */\nexport function planPluginTest(\n  spec: Record<string, unknown>,\n  flags: { env?: Record<string, string>; metadata?: Record<string, string>; vars?: Record<string, string> },\n  hostEnv: NodeJS.ProcessEnv = process.env,\n): TestPlan {\n  const metadata = { ...(spec.metadata as Record<string, string | number | boolean> ?? {}), ...(flags.metadata ?? {}) };\n  let resolved: Record<string, unknown>;\n  try {\n    resolved = resolvePluginTemplates(spec as never, {\n      pipeline: {\n        projectName: 'plugin-test',\n        project: 'plugin-test',\n        orgId: 'local',\n        organization: 'local',\n        pipelineName: 'plugin-test',\n        metadata,\n        vars: flags.vars ?? {},\n      },\n    }) as unknown as Record<string, unknown>;\n  } catch (err) {\n    throw new PluginTestFailure(`${(err as Error).message} — supply the value with --metadata KEY=VALUE or --var KEY=VALUE`);\n  }\n\n  const strings = (v: unknown): string[] => (Array.isArray(v) ? v.filter((c): c is string => typeof c === 'string') : []);\n  const env: Record<string, string> = {\n    ...(resolved.env as Record<string, string> ?? {}),\n    ...extractMetadataEnv(metadata),\n    ...(flags.env ?? {}),\n  };\n\n  const secrets = Array.isArray(spec.secrets) ? spec.secrets as Array<{ name: string; required: boolean }> : [];\n  const missingRequired = secrets.filter(s => s.required && !hostEnv[s.name]).map(s => s.name);\n  if (missingRequired.length) {\n    throw new PluginTestFailure(`Required secret(s) not set in your environment: ${missingRequired.join(', ')} — export them before running plugin test`);\n  }\n  const secretNames = secrets.filter(s => hostEnv[s.name]).map(s => s.name);\n  for (const name of secretNames) delete env[name];\n\n  const failureBehavior = resolveFailureBehavior(\n    typeof spec.category === 'string' ? spec.category : undefined,\n    spec.failureBehavior as 'fail' | 'warn' | 'ignore' | undefined,\n  );\n  const script = (commands: string[]): string => ['set -e', STEP_BOOTSTRAP_CMD, ...commands].join('\\n');\n  const timeout = typeof spec.timeout === 'number' && spec.timeout > 0 ? spec.timeout * 60_000 : undefined;\n\n  return {\n    name: String(spec.name),\n    version: String(spec.version),\n    failureBehavior,\n    env,\n    secretNames,\n    missingOptionalSecrets: secrets.filter(s => !s.required && !hostEnv[s.name]).map(s => s.name),\n    installScript: script(strings(resolved.installCommands)),\n    buildScript: script(wrapCommandsForFailureBehavior(strings(resolved.commands), failureBehavior)),\n    primaryOutputDirectory: typeof spec.primaryOutputDirectory === 'string' && spec.primaryOutputDirectory ? spec.primaryOutputDirectory : undefined,\n    smokeTest: typeof spec.smokeTest === 'string' && spec.smokeTest.trim() ? spec.smokeTest : undefined,\n    timeoutMs: timeout,\n  };\n}\n\n/** `docker run` arguments for one phase (secret VALUES never appear here). */\nexport function dockerRunArgs(image: string, workspace: string, plan: Pick<TestPlan, 'env' | 'secretNames'>, script: string): string[] {\n  return [\n    'run', '--rm',\n    '-v', `${workspace}:${CONTAINER_WORKSPACE}`, '-w', CONTAINER_WORKSPACE,\n    ...Object.entries(plan.env).flatMap(([k, v]) => ['-e', `${k}=${v}`]),\n    ...plan.secretNames.flatMap(name => ['-e', name]),\n    // CodeBuild runs a step's commands under /bin/sh, so the test does too.\n    '--entrypoint', '/bin/sh',\n    image, '-c', script,\n  ];\n}\n\n/** Copy the sample workspace to a scratch dir the container's uid 1000 can write. */\nexport function prepareWorkspace(source: string | undefined): string {\n  const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'pipeline-manager-plugin-test-'));\n  if (source) {\n    const src = path.resolve(source);\n    if (!fs.existsSync(src) || !fs.statSync(src).isDirectory()) throw new ValidationError(`--workspace is not a directory: ${src}`, 'workspace', src);\n    fs.cpSync(src, ws, { recursive: true });\n  }\n  // The container runs as the image's user (uid 1000), not the host user.\n  // Executable bits are kept (a `gradlew`), symlinks are left alone (never\n  // chmod through a link to something outside the scratch dir).\n  const open = (p: string): void => {\n    const st = fs.lstatSync(p);\n    if (st.isSymbolicLink()) return;\n    const ownerExecutable = Math.floor((st.mode % 0o1000) / 0o100) % 2 === 1;\n    fs.chmodSync(p, st.isDirectory() || ownerExecutable ? 0o777 : 0o666);\n    if (st.isDirectory()) for (const e of fs.readdirSync(p)) open(path.join(p, e));\n  };\n  open(ws);\n  return ws;\n}\n\n/** Where the step's primary output lands on the host, honouring a relative WORKDIR. */\nexport function outputPath(workspace: string, plan: Pick<TestPlan, 'env' | 'primaryOutputDirectory'>): string | null {\n  if (!plan.primaryOutputDirectory) return null;\n  const workdir = plan.env.WORKDIR ?? './';\n  const base = workdir.startsWith('/')\n    ? (workdir.startsWith(CONTAINER_WORKSPACE) ? path.join(workspace, path.relative(CONTAINER_WORKSPACE, workdir)) : null)\n    : path.join(workspace, workdir);\n  return base === null ? null : path.join(base, plan.primaryOutputDirectory);\n}\n\n/**\n * Build (or take) the image, then run the plugin as its CodeBuild step would:\n * install phase, build phase (failureBehavior applied), the primary output\n * check, then the spec's smokeTest. Any failure throws — a step that can't run\n * or that fails is red, never green.\n */\nexport async function runPluginTest(options: TestPluginOptions, exec: Exec = spawnExec): Promise<{ outputFiles: number | null }> {\n  const pkg = readPluginPackage(options.dir);\n  const problems = await packageProblems(pkg);\n  if (problems.length) {\n    for (const p of problems) printError(`  • ${p}`);\n    throw new ValidationError(`The plugin has ${problems.length} validation problem(s); run \"plugin validate\" and fix them first`);\n  }\n  const spec = pkg.spec as unknown as Record<string, unknown>;\n  if (spec.pluginType === 'ManualApprovalStep') {\n    throw new ValidationError('A ManualApprovalStep runs no commands, so there is nothing to test');\n  }\n  if (!hasTool(exec, 'docker')) throw new PluginTestFailure('docker is not available — plugin test runs the plugin in its image');\n\n  const plan = planPluginTest(spec, {\n    env: parseKeyValues(options.env, '--env'),\n    metadata: parseKeyValues(options.metadata, '--metadata'),\n    vars: parseKeyValues(options.var, '--var'),\n  });\n\n  const workspace = prepareWorkspace(options.workspace);\n  let image = options.image;\n  let built: string | null = null;\n  try {\n    if (!image) {\n      if (pkg.buildType === 'build_image') {\n        built = localImageTag(plan.name, plan.version);\n        printSection('Building image', built);\n        const buildArgs = (spec.buildArgs as Record<string, string>) ?? {};\n        const error = buildPluginImage(exec, { dir: pkg.dir, dockerfile: path.join(pkg.dir, pkg.dockerfileName), tag: built, buildArgs });\n        if (error) throw new PluginTestFailure(error);\n        image = built;\n      } else if (pkg.buildType === 'prebuilt') {\n        const r = exec('docker', ['load', '-i', path.join(pkg.dir, 'image.tar')]);\n        const loaded = /Loaded image(?: ID)?: (\\S+)/.exec(r.stdout)?.[1];\n        if (r.status !== 0 || !loaded) throw new PluginTestFailure(`docker load image.tar failed: ${(r.stderr || r.stdout).trim()}`);\n        image = loaded;\n      } else {\n        throw new ValidationError('A metadata_only plugin has no image of its own; pass the image it runs in with --image');\n      }\n    }\n    if (!image) throw new PluginTestFailure('No image to run');\n    const user = imageUser(exec, image);\n    if ('error' in user) throw new PluginTestFailure(user.error);\n    if (isRootUser(user.user)) {\n      throw new PluginTestFailure(`The image runs as root (USER '${user.user || '(unset)'}'); end the Dockerfile with \\`USER 1000:1000\\``);\n    }\n\n    printInfo('Running plugin', {\n      image,\n      runsAs: user.user,\n      workspace,\n      failureBehavior: plan.failureBehavior,\n      env: Object.keys(plan.env),\n      secrets: plan.secretNames,\n    });\n    if (plan.missingOptionalSecrets.length) printWarning('Optional secrets not set (the step runs without them)', { secrets: plan.missingOptionalSecrets });\n\n    for (const [phase, script] of [['install', plan.installScript], ['build', plan.buildScript]] as const) {\n      printSection(`Phase: ${phase}`);\n      const r = exec('docker', dockerRunArgs(image, workspace, plan, script), { inherit: true, timeoutMs: plan.timeoutMs });\n      if (r.error) throw new PluginTestFailure(`${phase} phase did not complete: ${r.error.message}`);\n      if (r.status !== 0) throw new PluginTestFailure(`${phase} phase failed (exit ${r.status})`);\n    }\n\n    let outputFiles: number | null = null;\n    const out = outputPath(workspace, plan);\n    if (plan.primaryOutputDirectory && out === null) {\n      printWarning('WORKDIR is outside the workspace; primaryOutputDirectory cannot be checked on the host');\n    } else if (out) {\n      if (!fs.existsSync(out) || !fs.statSync(out).isDirectory()) {\n        throw new PluginTestFailure(`primaryOutputDirectory '${plan.primaryOutputDirectory}' was not created`);\n      }\n      outputFiles = fs.readdirSync(out).length;\n      if (outputFiles === 0) throw new PluginTestFailure(`primaryOutputDirectory '${plan.primaryOutputDirectory}' is empty`);\n      printSuccess(`primaryOutputDirectory '${plan.primaryOutputDirectory}' has ${outputFiles} entr${outputFiles === 1 ? 'y' : 'ies'}`);\n    } else {\n      printWarning('The spec declares no primaryOutputDirectory; no output to check');\n    }\n\n    if (plan.smokeTest) {\n      printSection('Smoke test', plan.smokeTest);\n      const r = exec('docker', ['run', '--rm', '--entrypoint', '/bin/bash', image, '-c', plan.smokeTest], { inherit: true });\n      if (r.error || r.status !== 0) throw new PluginTestFailure(`smokeTest failed: ${plan.smokeTest}`);\n    } else {\n      printWarning('The spec declares no smokeTest');\n    }\n    return { outputFiles };\n  } finally {\n    if (options.keep) printInfo('Workspace kept', { workspace });\n    else fs.rmSync(workspace, { recursive: true, force: true });\n    if (built && !options.keep) removeImage(exec, built);\n  }\n}\n\n/**\n * Register `plugin test` — run a plugin's install + build commands locally in\n * its image against a sample workspace, check its primary output, and run its\n * smokeTest. Exits non-zero on any failure.\n *\n * Usage:\n *   pipeline-manager plugin test --dir ./my-linter --workspace ./sample-app\n *   pipeline-manager plugin test --dir ./my-linter --image my-linter:dev --metadata STAGE=dev\n */\nexport function testPlugin(program: Command): void {\n  program\n    .command('test')\n    .description('Run a plugin\\'s install + build commands locally in its image against a sample workspace')\n    .option('--dir <path>', 'Plugin directory', '.')\n    .option('--image <ref>', 'Use this image instead of building the plugin\\'s Dockerfile')\n    .option('--workspace <path>', 'Sample workspace copied in as the step\\'s source (default: empty)')\n    .option('--env <KEY=VALUE>', 'Extra environment variable (repeatable)', collect)\n    .option('--metadata <KEY=VALUE>', 'Pipeline metadata value (repeatable; also exported as env, as in the pipeline)', collect)\n    .option('--var <KEY=VALUE>', 'Pipeline var for {{ pipeline.vars.* }} (repeatable)', collect)\n    .option('--keep', 'Keep the scratch workspace and built image for inspection', false)\n    .action(async (options: TestPluginOptions) => {\n      const executionId = printCommandHeader('Test Plugin');\n      try {\n        const result = await runPluginTest(options);\n        printSuccess('Plugin test passed', { executionId, outputEntries: result.outputFiles });\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 test', executionId },\n        });\n      }\n    });\n}\n"]}

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

@@ -3,18 +3,17 @@ import { Command } from 'commander';
  * Registers the `upload-plugin` command with the CLI program.
  *
  * Validates a local plugin ZIP file (size, extension, readability),
- * builds a multipart form, and uploads it to the platform API.
- * Plugin name and version can be auto-detected from the package
- * or overridden via CLI flags.
+ * builds a multipart form, and uploads it to the platform API. The
+ * plugin's name and version always come from the package's
+ * `plugin-spec.yaml`, and the organization from the signed-in session.
  *
  * @param program - The root Commander program instance to attach the command to.
  *
  * @example
  * ```bash
- * cli plugin upload --file plugin.zip --organization acme
- * cli plugin upload --file plugin.zip --organization acme --public
- * cli plugin upload --file plugin.zip --organization acme --name my-plugin --version 1.0.0
- * cli plugin upload --file plugin.zip --organization acme --no-verify-ssl
+ * cli plugin upload --file plugin.zip
+ * cli plugin upload --file plugin.zip --public
+ * cli plugin upload --file plugin.zip --no-verify-ssl
  * ```
  */
 export declare function uploadPlugin(program: Command): void;

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

@@ -1 +1 @@
-{"version":3,"file":"upload-plugin.d.ts","sourceRoot":"","sources":["../../src/commands/upload-plugin.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoRnD"}
+{"version":3,"file":"upload-plugin.d.ts","sourceRoot":"","sources":["../../src/commands/upload-plugin.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8IpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6FnD"}