@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/login.d.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+/**
+ * Registers the `login` command with the CLI program.
+ *
+ * Authenticates against the platform API and prints an export statement
+ * for `PLATFORM_TOKEN` on success.  Does NOT require `PLATFORM_TOKEN`
+ * to be set beforehand (unlike other commands).
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager auth login --identifier admin@example.com --password secret
+ * pipeline-manager auth login -u admin@example.com -p secret
+ * pipeline-manager auth login -u admin@example.com -p secret --url https://myhost:8443
+ * eval $(pipeline-manager auth login -u admin@example.com -p secret --quiet)
+ * pipeline-manager auth login --refresh <refresh-token>
+ * ```
+ */
+export declare function login(program: Command): void;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoK5C"}

package/dist/commands/login.js

@@ -0,0 +1,174 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import axios from 'axios';
+import { Command } from 'commander';
+import pico from 'picocolors';
+import { TIMEOUTS } from '../config/cli.constants.js';
+import { assertCredentialTlsAllowed, credentialHttpsAgent, postLogin, resolveCredentials, switchOrganization } from '../utils/auth-utils.js';
+import { printCommandHeader, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printDebug, printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';
+import { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter.js';
+const { green } = pico;
+/**
+ * Registers the `login` command with the CLI program.
+ *
+ * Authenticates against the platform API and prints an export statement
+ * for `PLATFORM_TOKEN` on success.  Does NOT require `PLATFORM_TOKEN`
+ * to be set beforehand (unlike other commands).
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager auth login --identifier admin@example.com --password secret
+ * pipeline-manager auth login -u admin@example.com -p secret
+ * pipeline-manager auth login -u admin@example.com -p secret --url https://myhost:8443
+ * eval $(pipeline-manager auth login -u admin@example.com -p secret --quiet)
+ * pipeline-manager auth login --refresh <refresh-token>
+ * ```
+ */
+export function login(program) {
+    withSslOptions(program
+        .command('login')
+        .description('Authenticate with the platform and obtain a PLATFORM_TOKEN')
+        .option('-u, --identifier <identifier>', 'Username or email')
+        .option('-p, --password <password>', 'Password')
+        .option('--refresh <refreshToken>', 'Use a refresh token instead of login credentials')
+        .option('--org <orgId>', 'Switch to a specific organization after login')
+        .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443'))
+        .option('--quiet', 'Only print the export statement (useful for eval)')
+        .action(async (options) => {
+        const isRefresh = !!options.refresh;
+        const quiet = options.quiet ?? false;
+        const executionId = printCommandHeader(isRefresh ? 'Token Refresh' : 'Login', isRefresh ? 'Token Refresh' : 'Platform Authentication', { quiet });
+        // SECURITY: login/refresh POST plaintext passwords and JWTs. Never send them
+        // over an unverified TLS connection in production — a MITM would harvest them.
+        // In non-production, --no-verify-ssl is still honored (self-signed dev platforms).
+        assertCredentialTlsAllowed(options.verifySsl);
+        // Credentials may come from flags OR the PLATFORM_IDENTIFIER/PLATFORM_PASSWORD
+        // env vars (so the password need not appear in shell history / `ps`).
+        const { identifier, password } = resolveCredentials(options);
+        let loginSucceeded = false;
+        try {
+            // Validate required options
+            if (!isRefresh && (!identifier || !password)) {
+                printError('Login requires --identifier and --password (or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env), or --refresh <token>');
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            if (!isRefresh && options.password) {
+                printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');
+            }
+            // Rate limiting — prevent brute force (login only)
+            if (!isRefresh) {
+                const rateLimitMsg = checkAuthRateLimit(identifier, options.url);
+                if (rateLimitMsg) {
+                    printError(rateLimitMsg);
+                    process.exit(ERROR_CODES.AUTHENTICATION);
+                }
+            }
+            if (!quiet) {
+                printInfo(isRefresh ? 'Refreshing access token' : 'Authenticating', {
+                    ...(identifier ? { identifier } : {}),
+                    url: options.url,
+                    verifySsl: options.verifySsl,
+                });
+            }
+            const httpsAgent = credentialHttpsAgent(options.verifySsl);
+            let token;
+            if (isRefresh) {
+                const refreshUrl = `${options.url}/api/auth/refresh`;
+                printDebug('POST', { url: refreshUrl });
+                const response = await axios.post(refreshUrl, { refreshToken: options.refresh }, {
+                    headers: { 'Content-Type': 'application/json' },
+                    httpsAgent,
+                    timeout: TIMEOUTS.HTTP_REQUEST,
+                });
+                token = response.data?.data?.accessToken;
+            }
+            else {
+                // identifier/password validated non-null above (the `!isRefresh` guard).
+                token = await postLogin({
+                    url: options.url,
+                    identifier: identifier,
+                    password: password,
+                    httpsAgent,
+                    timeout: TIMEOUTS.HTTP_REQUEST,
+                });
+            }
+            if (!token) {
+                if (!isRefresh)
+                    recordAuthFailure(identifier, options.url);
+                printError(`${isRefresh ? 'Token refresh' : 'Login'} failed: no access token in response`);
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            if (!isRefresh)
+                recordAuthSuccess(identifier, options.url);
+            // Past this point authentication has already succeeded — a later failure
+            // (e.g. the --org switch below) must NOT be recorded as an auth failure,
+            // or a valid-credential user would accrue toward brute-force lockout.
+            loginSucceeded = true;
+            // Switch to a specific organization if --org is provided
+            if (options.org) {
+                if (!quiet) {
+                    printInfo('Switching to organization', { orgId: options.org });
+                }
+                token = await switchOrganization({
+                    url: options.url,
+                    orgId: options.org,
+                    accessToken: token,
+                    httpsAgent,
+                    timeout: TIMEOUTS.HTTP_REQUEST,
+                    quiet,
+                });
+            }
+            if (!quiet) {
+                console.log('');
+                printSuccess(isRefresh ? 'Token refreshed successfully' : 'Login successful');
+                console.log('');
+            }
+            console.log(`export PLATFORM_TOKEN=${token}`);
+            if (!quiet) {
+                console.log('');
+                printInfo('Tip: Run the following to set the token in your shell:');
+                const orgFlag = options.org ? ` --org ${options.org}` : '';
+                if (isRefresh) {
+                    console.log(green(`  eval $(pipeline-manager auth login --refresh '<refresh-token>'${orgFlag} --quiet)`));
+                }
+                else {
+                    console.log(green(`  eval $(pipeline-manager auth login -u ${identifier} -p '***'${orgFlag} --quiet)`));
+                }
+            }
+        }
+        catch (error) {
+            // Key the failure to (identifier, url) like the check/success/no-token
+            // paths — a bad-password 401 throws to here, so keying it to the shared
+            // default bucket meant brute-force attempts never accrued toward lockout.
+            // Skip when login already succeeded (a failed post-login --org switch is
+            // not an authentication failure).
+            if (!isRefresh && !loginSucceeded)
+                recordAuthFailure(identifier, options.url);
+            // Provide a clear failure message for auth errors
+            if (axios.isAxiosError(error)) {
+                const status = error.response?.status;
+                const message = error.response?.data?.message;
+                printError(`${isRefresh ? 'Token refresh' : 'Login'} failed`, {
+                    status: status ?? 'no response',
+                    ...(message ? { message } : {}),
+                });
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            handleError(error, ERROR_CODES.AUTHENTICATION, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'login',
+                    executionId,
+                    identifier: options.identifier,
+                    url: options.url,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login.js","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport axios from 'axios';\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport { TIMEOUTS } from '../config/cli.constants.js';\nimport { assertCredentialTlsAllowed, type AuthResponse, credentialHttpsAgent, postLogin, resolveCredentials, switchOrganization } from '../utils/auth-utils.js';\nimport { printCommandHeader, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printDebug, printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter.js';\n\nconst { green } = pico;\n\n/**\n * Registers the `login` command with the CLI program.\n *\n * Authenticates against the platform API and prints an export statement\n * for `PLATFORM_TOKEN` on success.  Does NOT require `PLATFORM_TOKEN`\n * to be set beforehand (unlike other commands).\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * pipeline-manager auth login --identifier admin@example.com --password secret\n * pipeline-manager auth login -u admin@example.com -p secret\n * pipeline-manager auth login -u admin@example.com -p secret --url https://myhost:8443\n * eval $(pipeline-manager auth login -u admin@example.com -p secret --quiet)\n * pipeline-manager auth login --refresh <refresh-token>\n * ```\n */\nexport function login(program: Command): void {\n  withSslOptions(program\n    .command('login')\n    .description('Authenticate with the platform and obtain a PLATFORM_TOKEN')\n    .option('-u, --identifier <identifier>', 'Username or email')\n    .option('-p, --password <password>', 'Password')\n    .option('--refresh <refreshToken>', 'Use a refresh token instead of login credentials')\n    .option('--org <orgId>', 'Switch to a specific organization after login')\n    .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443'))\n    .option('--quiet', 'Only print the export statement (useful for eval)')\n    .action(async (options) => {\n      const isRefresh = !!options.refresh;\n      const quiet = options.quiet ?? false;\n      const executionId = printCommandHeader(\n        isRefresh ? 'Token Refresh' : 'Login',\n        isRefresh ? 'Token Refresh' : 'Platform Authentication',\n        { quiet },\n      );\n\n      // SECURITY: login/refresh POST plaintext passwords and JWTs. Never send them\n      // over an unverified TLS connection in production — a MITM would harvest them.\n      // In non-production, --no-verify-ssl is still honored (self-signed dev platforms).\n      assertCredentialTlsAllowed(options.verifySsl);\n\n      // Credentials may come from flags OR the PLATFORM_IDENTIFIER/PLATFORM_PASSWORD\n      // env vars (so the password need not appear in shell history / `ps`).\n      const { identifier, password } = resolveCredentials(options);\n\n      let loginSucceeded = false;\n      try {\n\n        // Validate required options\n        if (!isRefresh && (!identifier || !password)) {\n          printError('Login requires --identifier and --password (or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env), or --refresh <token>');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        if (!isRefresh && options.password) {\n          printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n        }\n\n        // Rate limiting — prevent brute force (login only)\n        if (!isRefresh) {\n          const rateLimitMsg = checkAuthRateLimit(identifier, options.url);\n          if (rateLimitMsg) {\n            printError(rateLimitMsg);\n            process.exit(ERROR_CODES.AUTHENTICATION);\n          }\n        }\n\n        if (!quiet) {\n          printInfo(isRefresh ? 'Refreshing access token' : 'Authenticating', {\n            ...(identifier ? { identifier } : {}),\n            url: options.url,\n            verifySsl: options.verifySsl,\n          });\n        }\n\n        const httpsAgent = credentialHttpsAgent(options.verifySsl);\n\n        let token: string | undefined;\n\n        if (isRefresh) {\n          const refreshUrl = `${options.url}/api/auth/refresh`;\n          printDebug('POST', { url: refreshUrl });\n\n          const response = await axios.post<AuthResponse>(\n            refreshUrl,\n            { refreshToken: options.refresh },\n            {\n              headers: { 'Content-Type': 'application/json' },\n              httpsAgent,\n              timeout: TIMEOUTS.HTTP_REQUEST,\n            },\n          );\n\n          token = response.data?.data?.accessToken;\n        } else {\n          // identifier/password validated non-null above (the `!isRefresh` guard).\n          token = await postLogin({\n            url: options.url,\n            identifier: identifier!,\n            password: password!,\n            httpsAgent,\n            timeout: TIMEOUTS.HTTP_REQUEST,\n          });\n        }\n\n        if (!token) {\n          if (!isRefresh) recordAuthFailure(identifier, options.url);\n          printError(`${isRefresh ? 'Token refresh' : 'Login'} failed: no access token in response`);\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        if (!isRefresh) recordAuthSuccess(identifier, options.url);\n        // Past this point authentication has already succeeded — a later failure\n        // (e.g. the --org switch below) must NOT be recorded as an auth failure,\n        // or a valid-credential user would accrue toward brute-force lockout.\n        loginSucceeded = true;\n\n        // Switch to a specific organization if --org is provided\n        if (options.org) {\n          if (!quiet) {\n            printInfo('Switching to organization', { orgId: options.org });\n          }\n\n          token = await switchOrganization({\n            url: options.url,\n            orgId: options.org,\n            accessToken: token,\n            httpsAgent,\n            timeout: TIMEOUTS.HTTP_REQUEST,\n            quiet,\n          });\n        }\n\n        if (!quiet) {\n          console.log('');\n          printSuccess(isRefresh ? 'Token refreshed successfully' : 'Login successful');\n          console.log('');\n        }\n\n        console.log(`export PLATFORM_TOKEN=${token}`);\n\n        if (!quiet) {\n          console.log('');\n          printInfo('Tip: Run the following to set the token in your shell:');\n          const orgFlag = options.org ? ` --org ${options.org}` : '';\n          if (isRefresh) {\n            console.log(green(`  eval $(pipeline-manager auth login --refresh '<refresh-token>'${orgFlag} --quiet)`));\n          } else {\n            console.log(green(`  eval $(pipeline-manager auth login -u ${identifier} -p '***'${orgFlag} --quiet)`));\n          }\n        }\n      } catch (error) {\n        // Key the failure to (identifier, url) like the check/success/no-token\n        // paths — a bad-password 401 throws to here, so keying it to the shared\n        // default bucket meant brute-force attempts never accrued toward lockout.\n        // Skip when login already succeeded (a failed post-login --org switch is\n        // not an authentication failure).\n        if (!isRefresh && !loginSucceeded) recordAuthFailure(identifier, options.url);\n        // Provide a clear failure message for auth errors\n        if (axios.isAxiosError(error)) {\n          const status = error.response?.status;\n          const message = (error.response?.data as { message?: string })?.message;\n\n          printError(`${isRefresh ? 'Token refresh' : 'Login'} failed`, {\n            status: status ?? 'no response',\n            ...(message ? { message } : {}),\n          });\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        handleError(error, ERROR_CODES.AUTHENTICATION, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'login',\n            executionId,\n            identifier: options.identifier,\n            url: options.url,\n          },\n        });\n      }\n    });\n}\n"]}

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

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+/**
+ * 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.
+ *
+ * Usage:
+ *   pipeline-manager plugin new --name my-linter --category quality
+ *   pipeline-manager plugin new --name approve --type ManualApprovalStep
+ */
+export declare function newPlugin(program: Command): void;
+//# sourceMappingURL=new-plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"new-plugin.d.ts","sourceRoot":"","sources":["../../src/commands/new-plugin.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoBpC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA2GhD"}

package/dist/commands/new-plugin.js

@@ -0,0 +1,129 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import fs from 'fs';
+import path from 'path';
+import { Command } from 'commander';
+import YAML from 'yaml';
+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'];
+/**
+ * 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.
+ *
+ * Usage:
+ *   pipeline-manager plugin new --name my-linter --category quality
+ *   pipeline-manager plugin new --name approve --type ManualApprovalStep
+ */
+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')
+        .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('--dir <path>', 'Target directory (default ./<name>)')
+        .option('--force', 'Overwrite an existing directory', false)
+        .action((options) => {
+        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}`);
+            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');
+            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 });
+        }
+        catch (err) {
+            handleError(err, err instanceof ValidationError ? ERROR_CODES.VALIDATION : ERROR_CODES.GENERAL, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'new-plugin', 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"]}

package/dist/commands/org-export.d.ts

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+/**
+ * CLI  `pipeline-manager org export --id <orgId> --output <file>`.
+ *
+ * Fetches the GDPR portability dump from `GET /api/organization/:id/export`
+ * on the platform service and writes it to disk (or stdout). The endpoint
+ * is gated server-side * • System admins (admin/owner in the `system` org) may export any org.
+ * • Org admins / owners may export ONLY their own org.
+ * • Everything else gets 403.
+ *
+ * The CLI itself does no role checking  the caller's PLATFORM_TOKEN drives
+ * what the server accepts. Run `pipeline-manager status` first to confirm
+ * the token's role + org.
+ *
+ * @example
+ * ```bash
+ * # Sysadmin: any org
+ * pipeline-manager org export --id org-acme --output acme.json
+ *
+ * # Org admin: own org only (server rejects other ids with 403)
+ * pipeline-manager org export --id org-acme --output acme.json
+ * ```
+ */
+export declare function orgExport(program: Command): void;
+//# sourceMappingURL=org-export.d.ts.map

package/dist/commands/org-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-export.d.ts","sourceRoot":"","sources":["../../src/commands/org-export.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6EhD"}

package/dist/commands/org-export.js

@@ -0,0 +1,100 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import pico from 'picocolors';
+import { createAuthenticatedClient, printCommandHeader, printExecutionSummary, printSslWarning, validateEntityId, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printError, printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';
+const { bold, green } = pico;
+/**
+ * CLI  `pipeline-manager org export --id <orgId> --output <file>`.
+ *
+ * Fetches the GDPR portability dump from `GET /api/organization/:id/export`
+ * on the platform service and writes it to disk (or stdout). The endpoint
+ * is gated server-side * • System admins (admin/owner in the `system` org) may export any org.
+ * • Org admins / owners may export ONLY their own org.
+ * • Everything else gets 403.
+ *
+ * The CLI itself does no role checking  the caller's PLATFORM_TOKEN drives
+ * what the server accepts. Run `pipeline-manager status` first to confirm
+ * the token's role + org.
+ *
+ * @example
+ * ```bash
+ * # Sysadmin: any org
+ * pipeline-manager org export --id org-acme --output acme.json
+ *
+ * # Org admin: own org only (server rejects other ids with 403)
+ * pipeline-manager org export --id org-acme --output acme.json
+ * ```
+ */
+export function orgExport(program) {
+    withSslOptions(program
+        .command('export')
+        .description('Export an organization\'s data as JSON (GDPR portability, ).')
+        .requiredOption('-i, --id <id>', 'Organization ID to export')
+        .option('-o, --output <file>', 'Output file path (default: org-<id>-export.json in CWD)'))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Org Export');
+        try {
+            printSslWarning(options.verifySsl);
+            const orgId = validateEntityId(options.id, 'Organization');
+            const outputPath = options.output
+                ? path.resolve(options.output)
+                : path.resolve(process.cwd(), `org-${orgId}-export.json`);
+            printInfo('Request parameters', {
+                orgId,
+                output: outputPath,
+            });
+            const client = createAuthenticatedClient(options);
+            console.log('');
+            printSection('Fetching Export');
+            const startTime = Date.now();
+            // The endpoint streams a large JSON attachment for orgs with long
+            // histories. The ApiClient returns the parsed body directly, which
+            // for `application/json` is a JS object we re-serialize to disk.
+            const response = await client.get(`${client.getConfig().api.baseUrl}/api/organization/${encodeURIComponent(orgId)}/export`);
+            const duration = Date.now() - startTime;
+            if (!response || typeof response !== 'object') {
+                printError('Empty / unparseable export payload');
+                throw new Error(`Export returned no data for org ${orgId}`);
+            }
+            // Re-serialize so we keep the same pretty-printed shape the server
+            // produced (2-space indent matches the platform's handler) and so
+            // we don't lose Date precision on a round-trip through JSON.parse.
+            //
+            // GUARD: this writes the raw server payload straight to disk. The export
+            // payload must NEVER contain an AWS account id — orgId is the marketplace
+            // customerIdentifier, never an AWS account id. It is account-id-free today;
+            // if a future server change ever adds one, it must be stripped/redacted
+            // here BEFORE this write, not persisted through the CLI.
+            const json = JSON.stringify(response, null, 2);
+            fs.writeFileSync(outputPath, json, 'utf8');
+            const sizeKb = (json.length / 1024).toFixed(1);
+            const postgresTables = response.postgres && typeof response.postgres === 'object'
+                ? Object.keys(response.postgres).length
+                : 0;
+            console.log('');
+            printSection('Export Saved');
+            printKeyValue({
+                'Org ID': green(bold(orgId)),
+                'Output': outputPath,
+                'Size': `${sizeKb} KB`,
+                'Postgres tables': String(postgresTables),
+                'Exported at': typeof response.exportedAt === 'string' ? response.exportedAt : '(not set)',
+            });
+            printExecutionSummary(executionId, duration);
+            printSuccess('Organization export complete', { path: outputPath });
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'org-export', executionId, orgId: options.id },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-export.js","sourceRoot":"","sources":["../../src/commands/org-export.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport { createAuthenticatedClient, printCommandHeader, printExecutionSummary, printSslWarning, validateEntityId, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';\n\nconst { bold, green } = pico;\n\n/**\n * CLI  `pipeline-manager org export --id <orgId> --output <file>`.\n *\n * Fetches the GDPR portability dump from `GET /api/organization/:id/export`\n * on the platform service and writes it to disk (or stdout). The endpoint\n * is gated server-side * • System admins (admin/owner in the `system` org) may export any org.\n * • Org admins / owners may export ONLY their own org.\n * • Everything else gets 403.\n *\n * The CLI itself does no role checking  the caller's PLATFORM_TOKEN drives\n * what the server accepts. Run `pipeline-manager status` first to confirm\n * the token's role + org.\n *\n * @example\n * ```bash\n * # Sysadmin: any org\n * pipeline-manager org export --id org-acme --output acme.json\n *\n * # Org admin: own org only (server rejects other ids with 403)\n * pipeline-manager org export --id org-acme --output acme.json\n * ```\n */\nexport function orgExport(program: Command): void {\n  withSslOptions(program\n    .command('export')\n    .description('Export an organization\\'s data as JSON (GDPR portability, ).')\n    .requiredOption('-i, --id <id>', 'Organization ID to export')\n    .option('-o, --output <file>', 'Output file path (default: org-<id>-export.json in CWD)'))\n    .action(async (options) => {\n      const executionId = printCommandHeader('Org Export');\n\n      try {\n        printSslWarning(options.verifySsl);\n\n        const orgId = validateEntityId(options.id, 'Organization');\n        const outputPath = options.output\n          ? path.resolve(options.output)\n          : path.resolve(process.cwd(), `org-${orgId}-export.json`);\n\n        printInfo('Request parameters', {\n          orgId,\n          output: outputPath,\n        });\n\n        const client = createAuthenticatedClient(options);\n\n        console.log('');\n        printSection('Fetching Export');\n\n        const startTime = Date.now();\n        // The endpoint streams a large JSON attachment for orgs with long\n        // histories. The ApiClient returns the parsed body directly, which\n        // for `application/json` is a JS object we re-serialize to disk.\n        const response = await client.get<Record<string, unknown>>( `${client.getConfig().api.baseUrl}/api/organization/${encodeURIComponent(orgId)}/export`,\n        );\n        const duration = Date.now() - startTime;\n\n        if (!response || typeof response !== 'object') {\n          printError('Empty / unparseable export payload');\n          throw new Error(`Export returned no data for org ${orgId}`);\n        }\n\n        // Re-serialize so we keep the same pretty-printed shape the server\n        // produced (2-space indent matches the platform's handler) and so\n        // we don't lose Date precision on a round-trip through JSON.parse.\n        //\n        // GUARD: this writes the raw server payload straight to disk. The export\n        // payload must NEVER contain an AWS account id — orgId is the marketplace\n        // customerIdentifier, never an AWS account id. It is account-id-free today;\n        // if a future server change ever adds one, it must be stripped/redacted\n        // here BEFORE this write, not persisted through the CLI.\n        const json = JSON.stringify(response, null, 2);\n        fs.writeFileSync(outputPath, json, 'utf8');\n\n        const sizeKb = (json.length / 1024).toFixed(1);\n        const postgresTables = response.postgres && typeof response.postgres === 'object'\n          ? Object.keys(response.postgres as Record<string, unknown>).length\n          : 0;\n\n        console.log('');\n        printSection('Export Saved');\n        printKeyValue({\n          'Org ID': green(bold(orgId)),\n          'Output': outputPath,\n          'Size': `${sizeKb} KB`,\n          'Postgres tables': String(postgresTables),\n          'Exported at': typeof response.exportedAt === 'string' ? response.exportedAt: '(not set)',\n        });\n\n        printExecutionSummary(executionId, duration);\n        printSuccess('Organization export complete', { path: outputPath });\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'org-export', executionId, orgId: options.id },\n        });\n      }\n    });\n}\n"]}