@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/bootstrap.js

@@ -0,0 +1,159 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import pico from 'picocolors';
+import { assertShellSafe } from '../config/cli.constants.js';
+import { auditLog } from '../utils/audit-log.js';
+import { resolveAwsRegion } from '../utils/aws-env.js';
+import { executeCdkShellCommand } from '../utils/cdk-utils.js';
+import { printCommandHeader, withProfileOption, withRegionOption } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printError, printInfo, printKeyValue, printSection } from '../utils/output-utils.js';
+const { bold, cyan, dim } = pico;
+/**
+ * Resolves the AWS account ID from the CLI option or environment variable.
+ * @returns The account ID string, or `undefined` if not available.
+ */
+/** @internal Exported for testing only */
+export function resolveAccount(optionValue) {
+    return optionValue || process.env.AWS_ACCOUNT_ID || process.env.CDK_DEFAULT_ACCOUNT;
+}
+/**
+ * Resolves the AWS region from the CLI option or environment variable.
+ * @returns The region string, or `undefined` if not available.
+ */
+/** @internal Exported for testing only */
+export function resolveRegion(optionValue) {
+    return resolveAwsRegion(optionValue);
+}
+/**
+ * Builds the `cdk bootstrap` command string from the resolved options.
+ */
+/** @internal Exported for testing only */
+export function buildBootstrapCommand(options) {
+    // Every value below is interpolated into a string run via `execSync` (a shell),
+    // so validate ALL operator-supplied inputs — not just account/region/profile.
+    assertShellSafe(options.account, 'account');
+    assertShellSafe(options.region, 'region');
+    if (options.profile)
+        assertShellSafe(options.profile, 'profile');
+    if (options.qualifier)
+        assertShellSafe(options.qualifier, 'qualifier');
+    if (options.trust)
+        assertShellSafe(options.trust, 'trust');
+    if (options.cloudformationExecutionPolicies)
+        assertShellSafe(options.cloudformationExecutionPolicies, 'cloudformation-execution-policies');
+    const parts = [
+        'cdk',
+        'bootstrap',
+        `aws://${options.account}/${options.region}`,
+    ];
+    if (options.profile) {
+        parts.push(`--profile=${options.profile}`);
+    }
+    if (options.qualifier) {
+        parts.push(`--qualifier=${options.qualifier}`);
+    }
+    if (options.trust) {
+        parts.push(`--trust=${options.trust}`);
+    }
+    if (options.cloudformationExecutionPolicies) {
+        parts.push(`--cloudformation-execution-policies=${options.cloudformationExecutionPolicies}`);
+    }
+    return parts.join(' ');
+}
+/**
+ * Registers the `bootstrap` command with the CLI program.
+ *
+ * Provisions the CDK toolkit stack in the target AWS account/region
+ * so that CDK deployments can proceed.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export function bootstrap(program) {
+    withProfileOption(withRegionOption(program
+        .command('bootstrap')
+        .description('Bootstrap AWS CDK toolkit stack in target account/region')
+        .option('--account <id>', 'AWS account ID (defaults to AWS_ACCOUNT_ID or CDK_DEFAULT_ACCOUNT env)')))
+        .option('--qualifier <qualifier>', 'Bootstrap qualifier for environment isolation')
+        .option('--trust <accounts>', 'Comma-separated account IDs to trust for cross-account deployments')
+        .option('--cloudformation-execution-policies <arns>', 'IAM policy ARNs for CloudFormation execution role')
+        .option('--json', 'Output result as JSON', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('CDK Bootstrap', undefined, { quiet: options.json });
+        try {
+            // Never persist the AWS account id to the on-disk audit log (~/.pipeline-manager/audit.log).
+            // The audit module records operation metadata only — region/profile are safe; the account id is not.
+            auditLog('bootstrap', { executionId, region: options.region, profile: options.profile });
+            // Resolve account and region
+            const account = resolveAccount(options.account);
+            const region = resolveRegion(options.region);
+            if (!account) {
+                printError('AWS account ID is required');
+                console.log(dim('Provide --account <id> or set AWS_ACCOUNT_ID / CDK_DEFAULT_ACCOUNT environment variable'));
+                throw new Error('AWS account ID not provided');
+            }
+            printInfo('Bootstrap parameters', {
+                account,
+                region,
+                profile: options.profile,
+                qualifier: options.qualifier || '(default)',
+                trust: options.trust || '(none)',
+                cloudformationExecutionPolicies: options.cloudformationExecutionPolicies || '(none)',
+            });
+            // CDK availability is verified up front by the CLI's preAction hook.
+            // Build bootstrap command
+            const command = buildBootstrapCommand({
+                account,
+                region,
+                profile: options.profile,
+                qualifier: options.qualifier,
+                trust: options.trust,
+                cloudformationExecutionPolicies: options.cloudformationExecutionPolicies,
+            });
+            printSection('CDK Execution');
+            console.log(cyan(bold('Command:')), dim(command));
+            console.log('');
+            // Execute bootstrap
+            const result = executeCdkShellCommand(command, {
+                debug: program.opts().debug,
+                showOutput: true,
+            });
+            console.log('');
+            printSection('Bootstrap Complete');
+            if (result.success) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        executionId,
+                        account,
+                        region,
+                        duration: result.duration,
+                    }, null, 2));
+                }
+                else {
+                    printKeyValue({
+                        'Execution ID': executionId,
+                        'Account': account,
+                        'Region': region,
+                        'Duration': `${result.duration}ms`,
+                        'Status': '✓ Success',
+                    });
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.VALIDATION, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'bootstrap',
+                    executionId,
+                    account: options.account,
+                    region: options.region,
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/commands/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Command } from 'commander';\nimport pico from 'picocolors';\nimport { assertShellSafe } from '../config/cli.constants.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { resolveAwsRegion } from '../utils/aws-env.js';\nimport { executeCdkShellCommand } from '../utils/cdk-utils.js';\nimport { printCommandHeader, withProfileOption, withRegionOption } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection } from '../utils/output-utils.js';\n\nconst { bold, cyan, dim } = pico;\n\n/**\n * Resolves the AWS account ID from the CLI option or environment variable.\n * @returns The account ID string, or `undefined` if not available.\n */\n/** @internal Exported for testing only */\nexport function resolveAccount(optionValue?: string): string | undefined {\n  return optionValue || process.env.AWS_ACCOUNT_ID || process.env.CDK_DEFAULT_ACCOUNT;\n}\n\n/**\n * Resolves the AWS region from the CLI option or environment variable.\n * @returns The region string, or `undefined` if not available.\n */\n/** @internal Exported for testing only */\nexport function resolveRegion(optionValue?: string): string {\n  return resolveAwsRegion(optionValue);\n}\n\n/**\n * Builds the `cdk bootstrap` command string from the resolved options.\n */\n/** @internal Exported for testing only */\nexport function buildBootstrapCommand(options: {\n  account: string;\n  region: string;\n  profile?: string;\n  qualifier?: string;\n  trust?: string;\n  cloudformationExecutionPolicies?: string;\n}): string {\n  // Every value below is interpolated into a string run via `execSync` (a shell),\n  // so validate ALL operator-supplied inputs — not just account/region/profile.\n  assertShellSafe(options.account, 'account');\n  assertShellSafe(options.region, 'region');\n  if (options.profile) assertShellSafe(options.profile, 'profile');\n  if (options.qualifier) assertShellSafe(options.qualifier, 'qualifier');\n  if (options.trust) assertShellSafe(options.trust, 'trust');\n  if (options.cloudformationExecutionPolicies) assertShellSafe(options.cloudformationExecutionPolicies, 'cloudformation-execution-policies');\n\n  const parts: string[] = [\n    'cdk',\n    'bootstrap',\n    `aws://${options.account}/${options.region}`,\n  ];\n\n  if (options.profile) {\n    parts.push(`--profile=${options.profile}`);\n  }\n\n  if (options.qualifier) {\n    parts.push(`--qualifier=${options.qualifier}`);\n  }\n\n  if (options.trust) {\n    parts.push(`--trust=${options.trust}`);\n  }\n\n  if (options.cloudformationExecutionPolicies) {\n    parts.push(`--cloudformation-execution-policies=${options.cloudformationExecutionPolicies}`);\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Registers the `bootstrap` command with the CLI program.\n *\n * Provisions the CDK toolkit stack in the target AWS account/region\n * so that CDK deployments can proceed.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function bootstrap(program: Command): void {\n  withProfileOption(\n    withRegionOption(program\n      .command('bootstrap')\n      .description('Bootstrap AWS CDK toolkit stack in target account/region')\n      .option('--account <id>', 'AWS account ID (defaults to AWS_ACCOUNT_ID or CDK_DEFAULT_ACCOUNT env)')),\n  )\n    .option('--qualifier <qualifier>', 'Bootstrap qualifier for environment isolation')\n    .option('--trust <accounts>', 'Comma-separated account IDs to trust for cross-account deployments')\n    .option('--cloudformation-execution-policies <arns>', 'IAM policy ARNs for CloudFormation execution role')\n    .option('--json', 'Output result as JSON', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('CDK Bootstrap', undefined, { quiet: options.json });\n\n      try {\n        // Never persist the AWS account id to the on-disk audit log (~/.pipeline-manager/audit.log).\n        // The audit module records operation metadata only — region/profile are safe; the account id is not.\n        auditLog('bootstrap', { executionId, region: options.region, profile: options.profile });\n\n        // Resolve account and region\n        const account = resolveAccount(options.account);\n        const region = resolveRegion(options.region);\n\n        if (!account) {\n          printError('AWS account ID is required');\n          console.log(dim('Provide --account <id> or set AWS_ACCOUNT_ID / CDK_DEFAULT_ACCOUNT environment variable'));\n          throw new Error('AWS account ID not provided');\n        }\n\n        printInfo('Bootstrap parameters', {\n          account,\n          region,\n          profile: options.profile,\n          qualifier: options.qualifier || '(default)',\n          trust: options.trust || '(none)',\n          cloudformationExecutionPolicies: options.cloudformationExecutionPolicies || '(none)',\n        });\n\n        // CDK availability is verified up front by the CLI's preAction hook.\n\n        // Build bootstrap command\n        const command = buildBootstrapCommand({\n          account,\n          region,\n          profile: options.profile,\n          qualifier: options.qualifier,\n          trust: options.trust,\n          cloudformationExecutionPolicies: options.cloudformationExecutionPolicies,\n        });\n\n        printSection('CDK Execution');\n        console.log(cyan(bold('Command:')), dim(command));\n        console.log('');\n\n        // Execute bootstrap\n        const result = executeCdkShellCommand(command, {\n          debug: program.opts().debug,\n          showOutput: true,\n        });\n\n        console.log('');\n        printSection('Bootstrap Complete');\n\n        if (result.success) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              executionId,\n              account,\n              region,\n              duration: result.duration,\n            }, null, 2));\n          } else {\n            printKeyValue({\n              'Execution ID': executionId,\n              'Account': account,\n              'Region': region,\n              'Duration': `${result.duration}ms`,\n              'Status': '✓ Success',\n            });\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.VALIDATION, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'bootstrap',\n            executionId,\n            account: options.account,\n            region: options.region,\n          },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/create-pat.d.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+/**
+ * Registers the `create-pat` command with the CLI program.
+ *
+ * Mints a named Personal Access Token — a durable, individually-revocable API
+ * credential — for CI/automation. Unlike `login` (which returns a short-lived
+ * session token), a PAT is the right long-lived credential for scripts.
+ *
+ * The platform gates PAT creation behind step-up re-authentication, so this
+ * command chains three calls: login (→ access token), step-up with the same
+ * password (→ step-up token), then POST /user/pats. The PAT binds to the user's
+ * active org; pass `--org` to switch first (persists as the active org).
+ *
+ * The raw token is printed ONCE. `--quiet` prints only `export PLATFORM_TOKEN=…`
+ * so it can be `eval`'d — the PAT is itself a valid Bearer credential.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci-deploy -u ci@example.com
+ * pipeline-manager auth pat --name ci --expires-days 30 -u ci@example.com -p secret
+ * eval $(PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci -u ci@example.com --quiet)
+ * ```
+ */
+export declare function createPat(program: Command): void;
+//# sourceMappingURL=create-pat.d.ts.map

package/dist/commands/create-pat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pat.d.ts","sourceRoot":"","sources":["../../src/commands/create-pat.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4BpC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkLhD"}

package/dist/commands/create-pat.js

@@ -0,0 +1,194 @@
+// 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, printKeyValue, printSuccess, printWarning } from '../utils/output-utils.js';
+import { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter.js';
+const { bold, green, yellow } = pico;
+const MAX_EXPIRES_DAYS = 365;
+/**
+ * Registers the `create-pat` command with the CLI program.
+ *
+ * Mints a named Personal Access Token — a durable, individually-revocable API
+ * credential — for CI/automation. Unlike `login` (which returns a short-lived
+ * session token), a PAT is the right long-lived credential for scripts.
+ *
+ * The platform gates PAT creation behind step-up re-authentication, so this
+ * command chains three calls: login (→ access token), step-up with the same
+ * password (→ step-up token), then POST /user/pats. The PAT binds to the user's
+ * active org; pass `--org` to switch first (persists as the active org).
+ *
+ * The raw token is printed ONCE. `--quiet` prints only `export PLATFORM_TOKEN=…`
+ * so it can be `eval`'d — the PAT is itself a valid Bearer credential.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci-deploy -u ci@example.com
+ * pipeline-manager auth pat --name ci --expires-days 30 -u ci@example.com -p secret
+ * eval $(PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci -u ci@example.com --quiet)
+ * ```
+ */
+export function createPat(program) {
+    withSslOptions(program
+        .command('pat')
+        .description('Create a named Personal Access Token (long-lived CLI/automation credential)')
+        .requiredOption('--name <name>', 'Human-readable token name (e.g. ci-deploy)')
+        .option('--expires-days <days>', `Token lifetime in days (1-${MAX_EXPIRES_DAYS})`, '90')
+        .option('--scope <scope>', 'Optional token scope')
+        .option('-u, --identifier <identifier>', 'Username or email')
+        .option('-p, --password <password>', 'Password (prefer PLATFORM_PASSWORD env)')
+        .option('--org <orgId>', 'Bind the token to a specific organization (switches active org)')
+        .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) => {
+        // SECURITY: this POSTs a plaintext password (login + step-up). Never send it
+        // over an unverified TLS connection in production — a MITM would harvest it.
+        // Mirrors the guard in `login`. Non-production still honors --no-verify-ssl.
+        assertCredentialTlsAllowed(options.verifySsl);
+        // Credentials from flags OR PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env (so the
+        // password need not appear in shell history / `ps`).
+        const { identifier, password } = resolveCredentials(options);
+        const quiet = options.quiet ?? false;
+        const executionId = printCommandHeader('Create Personal Access Token', 'Create Personal Access Token', { quiet });
+        try {
+            // Validate name.
+            const name = typeof options.name === 'string' ? options.name.trim() : '';
+            if (!name) {
+                printError('Token name is required (--name)');
+                process.exit(ERROR_CODES.VALIDATION);
+            }
+            if (name.length > 100) {
+                printError('Token name must be 100 characters or fewer');
+                process.exit(ERROR_CODES.VALIDATION);
+            }
+            // Validate expiry → seconds.
+            const days = Math.floor(Number(options.expiresDays));
+            if (!Number.isFinite(days) || days < 1 || days > MAX_EXPIRES_DAYS) {
+                printError(`--expires-days must be an integer between 1 and ${MAX_EXPIRES_DAYS}`);
+                process.exit(ERROR_CODES.VALIDATION);
+            }
+            const expiresIn = days * 86400;
+            // Credentials required — step-up needs a password, so --refresh can't work here.
+            if (!identifier || !password) {
+                printError('create-pat requires --identifier and --password (or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env)');
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            if (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 (keyed to identifier + url, like login).
+            const rateLimitMsg = checkAuthRateLimit(identifier, options.url);
+            if (rateLimitMsg) {
+                printError(rateLimitMsg);
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            if (!quiet) {
+                printInfo('Authenticating', { identifier, url: options.url, verifySsl: options.verifySsl });
+            }
+            const httpsAgent = credentialHttpsAgent(options.verifySsl);
+            const timeout = TIMEOUTS.HTTP_REQUEST;
+            // 1) Login → session access token.
+            let accessToken;
+            try {
+                accessToken = await postLogin({ url: options.url, identifier, password, httpsAgent, timeout });
+            }
+            catch (error) {
+                recordAuthFailure(identifier, options.url);
+                throw error;
+            }
+            if (!accessToken) {
+                recordAuthFailure(identifier, options.url);
+                printError('Login failed: no access token in response');
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            recordAuthSuccess(identifier, options.url);
+            // 2) Optionally bind to a specific org (persists as the active org, which the
+            //    PAT inherits).
+            if (options.org) {
+                if (!quiet)
+                    printInfo('Switching to organization', { orgId: options.org });
+                accessToken = await switchOrganization({
+                    url: options.url,
+                    orgId: options.org,
+                    accessToken,
+                    httpsAgent,
+                    timeout,
+                    quiet,
+                });
+            }
+            // 3) Step-up — re-verify the password to unlock the gated create call.
+            //    The returned token is short-lived (~60s), so we use it immediately.
+            const stepUpUrl = `${options.url}/api/auth/step-up`;
+            printDebug('POST', { url: stepUpUrl });
+            const stepUpRes = await axios.post(stepUpUrl, { password }, { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${accessToken}` }, httpsAgent, timeout });
+            const stepUpToken = stepUpRes.data?.data?.stepUpToken;
+            if (!stepUpToken) {
+                printError('Step-up verification failed: no step-up token in response');
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            // 4) Create the PAT.
+            const patUrl = `${options.url}/api/user/pats`;
+            printDebug('POST', { url: patUrl });
+            const patRes = await axios.post(patUrl, { name, expiresIn, ...(options.scope ? { scope: options.scope } : {}) }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${accessToken}`,
+                    'X-Step-Up-Token': stepUpToken,
+                },
+                httpsAgent,
+                timeout,
+            });
+            const token = patRes.data?.data?.token;
+            const pat = patRes.data?.data?.pat;
+            if (!token) {
+                printError('Create token failed: no token in response');
+                process.exit(ERROR_CODES.API_REQUEST);
+            }
+            // Quiet mode: emit only the export line (the PAT is a valid Bearer token).
+            if (quiet) {
+                console.log(`export PLATFORM_TOKEN=${token}`);
+                return;
+            }
+            console.log('');
+            printSuccess('Personal access token created');
+            console.log('');
+            printKeyValue({
+                'Name': pat?.name ?? name,
+                'Token ID (jti)': pat?.jti ?? '(unknown)',
+                'Expires': pat?.expiresAt ?? `${days} day(s)`,
+                ...(pat?.scope ? { Scope: pat.scope } : {}),
+            });
+            console.log('');
+            console.log(yellow(bold('Copy your token now — it will not be shown again:')));
+            console.log(green(token));
+            console.log('');
+            printInfo('Tip: use it as PLATFORM_TOKEN for subsequent commands:');
+            console.log(green('  export PLATFORM_TOKEN=<token>'));
+            console.log(green(`  # or:  eval $(pipeline-manager auth pat --name ${name} -u ${identifier} --quiet)`));
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                const status = error.response?.status;
+                const message = error.response?.data?.message;
+                printError('Create token failed', {
+                    status: status ?? 'no response',
+                    ...(message ? { message } : {}),
+                });
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'create-pat', executionId, identifier: options.identifier, url: options.url },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-pat.js","sourceRoot":"","sources":["../../src/commands/create-pat.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, 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, printKeyValue, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter.js';\n\nconst { bold, green, yellow } = pico;\n\n/** Step-up response — a short-lived (60s) JWT bound to the user's sub. */\ninterface StepUpResponse {\n  success: boolean;\n  data: { stepUpToken: string };\n}\n\n/** Create-PAT response — the raw token is returned exactly once. */\ninterface CreatePatResponse {\n  success: boolean;\n  data: {\n    token: string;\n    pat: { jti: string; name: string; expiresAt: string; scope?: string | null };\n  };\n}\n\nconst MAX_EXPIRES_DAYS = 365;\n\n/**\n * Registers the `create-pat` command with the CLI program.\n *\n * Mints a named Personal Access Token — a durable, individually-revocable API\n * credential — for CI/automation. Unlike `login` (which returns a short-lived\n * session token), a PAT is the right long-lived credential for scripts.\n *\n * The platform gates PAT creation behind step-up re-authentication, so this\n * command chains three calls: login (→ access token), step-up with the same\n * password (→ step-up token), then POST /user/pats. The PAT binds to the user's\n * active org; pass `--org` to switch first (persists as the active org).\n *\n * The raw token is printed ONCE. `--quiet` prints only `export PLATFORM_TOKEN=…`\n * so it can be `eval`'d — the PAT is itself a valid Bearer credential.\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci-deploy -u ci@example.com\n * pipeline-manager auth pat --name ci --expires-days 30 -u ci@example.com -p secret\n * eval $(PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci -u ci@example.com --quiet)\n * ```\n */\nexport function createPat(program: Command): void {\n  withSslOptions(program\n    .command('pat')\n    .description('Create a named Personal Access Token (long-lived CLI/automation credential)')\n    .requiredOption('--name <name>', 'Human-readable token name (e.g. ci-deploy)')\n    .option('--expires-days <days>', `Token lifetime in days (1-${MAX_EXPIRES_DAYS})`, '90')\n    .option('--scope <scope>', 'Optional token scope')\n    .option('-u, --identifier <identifier>', 'Username or email')\n    .option('-p, --password <password>', 'Password (prefer PLATFORM_PASSWORD env)')\n    .option('--org <orgId>', 'Bind the token to a specific organization (switches active org)')\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      // SECURITY: this POSTs a plaintext password (login + step-up). Never send it\n      // over an unverified TLS connection in production — a MITM would harvest it.\n      // Mirrors the guard in `login`. Non-production still honors --no-verify-ssl.\n      assertCredentialTlsAllowed(options.verifySsl);\n\n      // Credentials from flags OR PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env (so the\n      // password need not appear in shell history / `ps`).\n      const { identifier, password } = resolveCredentials(options);\n      const quiet = options.quiet ?? false;\n      const executionId = printCommandHeader(\n        'Create Personal Access Token',\n        'Create Personal Access Token',\n        { quiet },\n      );\n\n      try {\n        // Validate name.\n        const name = typeof options.name === 'string' ? options.name.trim() : '';\n        if (!name) {\n          printError('Token name is required (--name)');\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n        if (name.length > 100) {\n          printError('Token name must be 100 characters or fewer');\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n\n        // Validate expiry → seconds.\n        const days = Math.floor(Number(options.expiresDays));\n        if (!Number.isFinite(days) || days < 1 || days > MAX_EXPIRES_DAYS) {\n          printError(`--expires-days must be an integer between 1 and ${MAX_EXPIRES_DAYS}`);\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n        const expiresIn = days * 86400;\n\n        // Credentials required — step-up needs a password, so --refresh can't work here.\n        if (!identifier || !password) {\n          printError('create-pat requires --identifier and --password (or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env)');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        if (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 (keyed to identifier + url, like login).\n        const rateLimitMsg = checkAuthRateLimit(identifier, options.url);\n        if (rateLimitMsg) {\n          printError(rateLimitMsg);\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        if (!quiet) {\n          printInfo('Authenticating', { identifier, url: options.url, verifySsl: options.verifySsl });\n        }\n\n        const httpsAgent = credentialHttpsAgent(options.verifySsl);\n        const timeout = TIMEOUTS.HTTP_REQUEST;\n\n        // 1) Login → session access token.\n        let accessToken: string | undefined;\n        try {\n          accessToken = await postLogin({ url: options.url, identifier, password, httpsAgent, timeout });\n        } catch (error) {\n          recordAuthFailure(identifier, options.url);\n          throw error;\n        }\n        if (!accessToken) {\n          recordAuthFailure(identifier, options.url);\n          printError('Login failed: no access token in response');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        recordAuthSuccess(identifier, options.url);\n\n        // 2) Optionally bind to a specific org (persists as the active org, which the\n        //    PAT inherits).\n        if (options.org) {\n          if (!quiet) printInfo('Switching to organization', { orgId: options.org });\n          accessToken = await switchOrganization({\n            url: options.url,\n            orgId: options.org,\n            accessToken,\n            httpsAgent,\n            timeout,\n            quiet,\n          });\n        }\n\n        // 3) Step-up — re-verify the password to unlock the gated create call.\n        //    The returned token is short-lived (~60s), so we use it immediately.\n        const stepUpUrl = `${options.url}/api/auth/step-up`;\n        printDebug('POST', { url: stepUpUrl });\n        const stepUpRes = await axios.post<StepUpResponse>(\n          stepUpUrl,\n          { password },\n          { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${accessToken}` }, httpsAgent, timeout },\n        );\n        const stepUpToken = stepUpRes.data?.data?.stepUpToken;\n        if (!stepUpToken) {\n          printError('Step-up verification failed: no step-up token in response');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        // 4) Create the PAT.\n        const patUrl = `${options.url}/api/user/pats`;\n        printDebug('POST', { url: patUrl });\n        const patRes = await axios.post<CreatePatResponse>(\n          patUrl,\n          { name, expiresIn, ...(options.scope ? { scope: options.scope } : {}) },\n          {\n            headers: {\n              'Content-Type': 'application/json',\n              'Authorization': `Bearer ${accessToken}`,\n              'X-Step-Up-Token': stepUpToken,\n            },\n            httpsAgent,\n            timeout,\n          },\n        );\n\n        const token = patRes.data?.data?.token;\n        const pat = patRes.data?.data?.pat;\n        if (!token) {\n          printError('Create token failed: no token in response');\n          process.exit(ERROR_CODES.API_REQUEST);\n        }\n\n        // Quiet mode: emit only the export line (the PAT is a valid Bearer token).\n        if (quiet) {\n          console.log(`export PLATFORM_TOKEN=${token}`);\n          return;\n        }\n\n        console.log('');\n        printSuccess('Personal access token created');\n        console.log('');\n        printKeyValue({\n          'Name': pat?.name ?? name,\n          'Token ID (jti)': pat?.jti ?? '(unknown)',\n          'Expires': pat?.expiresAt ?? `${days} day(s)`,\n          ...(pat?.scope ? { Scope: pat.scope } : {}),\n        });\n        console.log('');\n        console.log(yellow(bold('Copy your token now — it will not be shown again:')));\n        console.log(green(token));\n        console.log('');\n        printInfo('Tip: use it as PLATFORM_TOKEN for subsequent commands:');\n        console.log(green('  export PLATFORM_TOKEN=<token>'));\n        console.log(green(`  # or:  eval $(pipeline-manager auth pat --name ${name} -u ${identifier} --quiet)`));\n      } catch (error) {\n        if (axios.isAxiosError(error)) {\n          const status = error.response?.status;\n          const message = (error.response?.data as { message?: string })?.message;\n          printError('Create token failed', {\n            status: status ?? 'no response',\n            ...(message ? { message } : {}),\n          });\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'create-pat', executionId, identifier: options.identifier, url: options.url },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/create-pipeline.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+/**
+ * Registers the `create-pipeline` command with the CLI program.
+ *
+ * Accepts a pipeline properties JSON file, validates it, resolves
+ * project/organization from CLI flags or the props file, and
+ * creates the pipeline via the platform API.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ */
+export declare function createPipeline(program: Command): void;
+//# sourceMappingURL=create-pipeline.d.ts.map

package/dist/commands/create-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pipeline.d.ts","sourceRoot":"","sources":["../../src/commands/create-pipeline.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuUrD"}