@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/store-token.js

@@ -0,0 +1,305 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import * as os from 'os';
+import path from 'path';
+import { LambdaClient, UpdateFunctionCodeCommand } from '@aws-sdk/client-lambda';
+import { Command } from 'commander';
+import { APP_VERSION, validateNumber } from '../config/cli.constants.js';
+import { auditLog } from '../utils/audit-log.js';
+import { decodeTokenPayload } from '../utils/auth-guard.js';
+import { resolveAwsRegion } from '../utils/aws-env.js';
+import { upsertSecret, getSecretArn } from '../utils/aws-secrets.js';
+import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withProfileOption, withRegionOption, withSslOptions } from '../utils/command-utils.js';
+import { toEventBridgeCron } from '../utils/cron.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';
+import { ensurePlatformToken, resolveSecretName } from '../utils/platform-secret.js';
+// ESM has no __dirname; derive it from this module's URL.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RENEW_STACK_NAME = 'pipeline-builder-token-renew';
+// CFN-managed Lambda function name — keep in sync with token-renew-stack.json.
+const RENEW_LAMBDA_NAME = 'pipeline-builder-token-renew';
+// Default 5-field cron (daily at midnight) when neither --cron nor TOKEN_RENEW_SCHEDULE is set.
+const DEFAULT_RENEW_CRON = '0 0 * * *';
+/**
+ * Deploy (or update) the once-a-day token-renewal stack: a scheduled Lambda that
+ * re-mints the platform JWT in this same secret before it expires. Mirrors
+ * setup-events — `aws cloudformation deploy` for the infra, then a direct
+ * UpdateFunctionCode with the thin orchestrator handler compiled alongside this
+ * CLI (the handler npm-installs pipeline-manager at runtime and re-runs
+ * store-token; see src/lambda/token-renew-handler.ts).
+ */
+async function deployRenewSchedule(opts) {
+    const scheduleExpression = toEventBridgeCron(opts.fiveFieldCron); // validates + 15-min guard
+    // Name renewal resources per-secret so a scoped-token stack (e.g. the
+    // reporting-ingest credential the event Lambda reads) coexists with the
+    // platform-token stack instead of colliding on the (account-global) IAM
+    // role / Lambda / rule names. The platform secret keeps the bare name
+    // (suffix '') so existing deployments' stack is updated in place, not
+    // duplicated; any other secret appends its trailing path segment.
+    const secretLeaf = opts.secretName.replace(/.*\//, ''); // 'platform' | 'reporting-ingest' | …
+    const nameSuffix = secretLeaf === 'platform' ? '' : `-${secretLeaf.replace(/[^a-z0-9]+/gi, '-')}`;
+    const stackName = `${RENEW_STACK_NAME}${nameSuffix}`;
+    const lambdaName = `${RENEW_LAMBDA_NAME}${nameSuffix}`;
+    printSection('Schedule Renewal');
+    printInfo('Parameters', {
+        stack: stackName,
+        schedule: opts.fiveFieldCron,
+        eventbridge: scheduleExpression,
+        renewDays: opts.days,
+    });
+    // Step 1: infra (Lambda gets placeholder code on first create).
+    const templatePath = path.join(__dirname, '../templates/token-renew-stack.json');
+    const cfnArgs = [
+        'cloudformation', 'deploy',
+        '--stack-name', stackName,
+        '--template-file', templatePath,
+        '--parameter-overrides',
+        `PlatformBaseUrl=${opts.platformUrl}`,
+        `PlatformSecretName=${opts.secretName}`,
+        `RenewDays=${opts.days}`,
+        `ScheduleExpression=${scheduleExpression}`,
+        `NameSuffix=${nameSuffix}`,
+        // Pin the handler's runtime npm install to THIS CLI's version (reproducible
+        // renewals instead of a floating "latest").
+        `PipelineManagerVersion=${APP_VERSION}`,
+        '--capabilities', 'CAPABILITY_NAMED_IAM',
+        '--no-fail-on-empty-changeset',
+        '--region', opts.region,
+    ];
+    if (opts.profile)
+        cfnArgs.push('--profile', opts.profile);
+    execFileSync('aws', cfnArgs, { stdio: 'inherit' });
+    // Step 2: upload the real handler. It's ESM, so the zip entry must be index.mjs
+    // (Handler stays index.handler — nodejs24.x resolves the .mjs extension).
+    const handlerSrc = path.join(__dirname, '../lambda/token-renew-handler.js');
+    if (!fs.existsSync(handlerSrc)) {
+        throw new Error(`Token-renew handler not found at ${handlerSrc} — was the package built?`);
+    }
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-renew-'));
+    try {
+        fs.copyFileSync(handlerSrc, path.join(tmpDir, 'index.mjs'));
+        const zipPath = path.join(tmpDir, 'index.zip');
+        execFileSync('zip', ['-j', zipPath, 'index.mjs'], { cwd: tmpDir, stdio: 'pipe' });
+        const lambdaClient = new LambdaClient({ region: opts.region });
+        await lambdaClient.send(new UpdateFunctionCodeCommand({
+            FunctionName: lambdaName,
+            ZipFile: fs.readFileSync(zipPath),
+        }));
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    printSuccess(`Renewal scheduled (${scheduleExpression})`);
+    return scheduleExpression;
+}
+/**
+ * Registers the `store-token` command with the CLI program.
+ *
+ * Generates a long-lived JWT token via the platform API and stores it
+ * in AWS Secrets Manager for use by the synth/deploy --store-tokens flag.
+ *
+ * Requires PLATFORM_TOKEN to be set, or use --email/--password to login inline.
+ *
+ * By default it ONLY writes the secret. Pass --schedule to also deploy the daily
+ * token-renewal stack (a Lambda that auto-renews this token before it expires).
+ *
+ * @example
+ * ```bash
+ * pipeline-manager infra store-token --region us-east-1
+ * pipeline-manager infra store-token --days 90 --region us-east-1
+ * pipeline-manager infra store-token --schedule --region us-east-1          # + daily auto-renewal
+ * pipeline-manager infra store-token --schedule --cron '0 3 * * *'          # custom renewal time
+ * pipeline-manager infra store-token --days 7 --no-verify-ssl
+ * PLATFORM_SECRET_NAME=my-custom-secret pipeline-manager infra store-token   # override the derived name
+ * pipeline-manager infra store-token --dry-run
+ * pipeline-manager infra store-token -e admin -p '***' --region us-east-1
+ * ```
+ */
+export function storeToken(program) {
+    withSslOptions(withProfileOption(withRegionOption(program
+        .command('store-token')
+        .description('Generate JWT token and store in AWS Secrets Manager for CDK deployments')
+        .option('-u, --identifier <identifier>', 'Username or email (skips PLATFORM_TOKEN requirement)')
+        .option('-p, --password <password>', 'Login password (used with --identifier)')
+        .option('--days <days>', 'Token lifetime in days', '30')
+        .option('--scope <scope>', 'Mint a narrow-scope machine token (e.g. "reporting:ingest") and store it at a scope-specific secret path instead of the shared platform secret')
+        .option('--dry-run', 'Show what would be stored without writing to Secrets Manager', false)))
+        .option('--schedule', 'Also deploy the daily token-renewal stack that auto-renews this token (off by default)', false)
+        .option('--cron <expr>', 'Renewal schedule as a 5-field cron, used with --schedule (default: TOKEN_RENEW_SCHEDULE env or "0 0 * * *"; min every 15 minutes)')
+        .option('--json', 'Output result as JSON', false))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Store Token', undefined, { quiet: options.json });
+        try {
+            printSslWarning(options.verifySsl);
+            const region = resolveAwsRegion(options.region);
+            const days = validateNumber(options.days, 'days', 1, 365);
+            const expiresInSeconds = days * 24 * 60 * 60;
+            // Step 0: log in first when creds are available and no PLATFORM_TOKEN is set
+            // (shared with setup-events). Creds come from --email/--password OR the env
+            // vars PLATFORM_IDENTIFIER/PLATFORM_PASSWORD — the env path lets callers like
+            // `provision --with-events` pass them without putting the password on the
+            // command line (where it would show in plans/logs).
+            await ensurePlatformToken(options);
+            // Step 1: Authenticate and generate long-lived token
+            printSection('Generate Token');
+            const client = await createAuthenticatedClientAsync(options);
+            // Resolve secret name from the token's organizationId. An explicit
+            // PLATFORM_SECRET_NAME env wins (escape hatch for system/no-org tokens and
+            // the renewal Lambda); otherwise derive `{prefix}/{orgId}/platform`.
+            // A `--scope` token is a distinct machine credential — store it at a
+            // scope-specific path (`.../reporting-ingest`) so it never clobbers the
+            // full-privilege platform token used by synth/deploy callbacks.
+            const scope = options.scope;
+            const baseSecretName = process.env.PLATFORM_SECRET_NAME || resolveSecretName(process.env.PLATFORM_TOKEN);
+            const secretName = scope && !process.env.PLATFORM_SECRET_NAME
+                ? baseSecretName.replace(/\/platform$/, `/${scope.replace(/[^a-z0-9]+/gi, '-')}`)
+                : baseSecretName;
+            auditLog('store-token', { executionId, secretName, days, dryRun: options.dryRun });
+            printInfo('Parameters', {
+                secretName,
+                region,
+                days,
+                expiresIn: `${expiresInSeconds}s`,
+                dryRun: options.dryRun,
+            });
+            printInfo('Requesting token', { expiresIn: `${expiresInSeconds}s (${days} days)` });
+            const tokenResponse = await client.post('/api/user/generate-token', { expiresIn: expiresInSeconds, ...(scope ? { scope } : {}) });
+            const tokenData = tokenResponse?.data ?? tokenResponse;
+            const accessToken = tokenData?.accessToken;
+            const refreshToken = tokenData?.refreshToken;
+            const actualExpiresIn = tokenData?.expiresIn ?? expiresInSeconds;
+            if (!accessToken) {
+                throw new Error('Token generation failed — no access token in response');
+            }
+            printSuccess(`Token generated (expires in ${actualExpiresIn}s)`);
+            const expiresAt = new Date(Date.now() + actualExpiresIn * 1000).toISOString();
+            // Schema: { username: orgId, password: JWT, ...metadata }
+            // - username/password fields satisfy CodeBuild's `secretsManagerCredentials`
+            //   (HTTP Basic, sent to pipeline-image-registry's /token endpoint)
+            // - The same JWT is consumed by the plugin-lookup Lambda by reading
+            //   the `password` field
+            // - One Secret per customer account replaces the previous two-secret model
+            // Decode JWT for orgId — it's a stable identifier for the username field;
+            // the actual auth uses the password (JWT) which the token service verifies.
+            // `||` (not `??`): an EMPTY-string organizationId must also fall back. A
+            // sysadmin/system token often carries organizationId="", and CodeBuild
+            // rejects a registry credential whose `username` field is empty with
+            // "AuthorizationData is malformed, empty field" — so username must always
+            // be a non-empty value.
+            const payload = decodeTokenPayload(accessToken);
+            const orgId = payload?.organizationId?.trim() || 'unknown-org';
+            const secretValue = JSON.stringify({
+                username: orgId,
+                // `password` is the canonical JWT field — read by CodeBuild creds,
+                // plugin-lookup, token-renew, and the event-ingestion Lambda.
+                password: accessToken,
+                ...(refreshToken && { refreshToken }),
+                platformUrl: client.getBaseUrl(),
+                expiresIn: actualExpiresIn,
+                expiresAt,
+                createdAt: new Date().toISOString(),
+            });
+            // Dry-run: show what would be stored
+            if (options.dryRun) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        dryRun: true,
+                        secretName,
+                        region,
+                        expiresInDays: days,
+                        expiresAt,
+                        tokenLength: accessToken.length,
+                        hasRefreshToken: !!refreshToken,
+                    }, null, 2));
+                }
+                else {
+                    console.log('');
+                    printSection('Dry Run — No Changes Made');
+                    printKeyValue({
+                        'Secret Name': secretName,
+                        'Region': region,
+                        'Expires In': `${days} days`,
+                        'Renew By': expiresAt,
+                        'Token Length': `${accessToken.length} chars`,
+                        'Has Refresh Token': refreshToken ? 'Yes' : 'No',
+                    });
+                    printSuccess('Dry run complete — no secret was created or updated');
+                }
+                return;
+            }
+            // Step 2: Store token in Secrets Manager
+            printSection('Store Token');
+            const description = `Platform JWT token (renew by ${expiresAt})`;
+            await upsertSecret(secretName, secretValue, description, { region, profile: options.profile });
+            const arn = await getSecretArn(secretName, { region, profile: options.profile });
+            // Optionally install the once-a-day renewal stack so this token never lapses.
+            // Off by default — opt in with --schedule (e.g. for the AWS event-ingestion
+            // bundle whose Lambda needs a non-expiring token).
+            let scheduleExpression;
+            if (options.schedule) {
+                const fiveFieldCron = options.cron || process.env.TOKEN_RENEW_SCHEDULE || DEFAULT_RENEW_CRON;
+                scheduleExpression = await deployRenewSchedule({
+                    platformUrl: client.getBaseUrl(),
+                    secretName,
+                    days,
+                    fiveFieldCron,
+                    region,
+                    profile: options.profile,
+                });
+            }
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: true,
+                    secretName,
+                    secretArn: arn,
+                    region,
+                    expiresInDays: days,
+                    expiresAt,
+                    schedule: scheduleExpression ?? null,
+                }, null, 2));
+            }
+            else {
+                console.log('');
+                printSection('Token Stored');
+                printKeyValue({
+                    'Secret Name': secretName,
+                    'Secret ARN': arn,
+                    'Region': region,
+                    'Expires In': `${days} days`,
+                    'Renew By': expiresAt,
+                    'Auto-Renew': scheduleExpression ? `✓ ${scheduleExpression}` : 'off (pass --schedule to enable)',
+                    'Status': '✓ Stored',
+                });
+                console.log('');
+                printSuccess('Token stored. To use with synth/deploy:');
+                printInfo(`  export PLATFORM_SECRET_NAME=${secretName}`);
+                printInfo('  pipeline-manager pipeline synth --id <pipeline-id> --store-tokens');
+                console.log('');
+                if (scheduleExpression) {
+                    printInfo(`Auto-renewal is active (${scheduleExpression}); the secret refreshes before ${expiresAt}.`);
+                }
+                else {
+                    printInfo(`Renew before ${expiresAt} with: pipeline-manager infra store-token --days ${days}`);
+                    printInfo('  (or pass --schedule to install a daily auto-renewal stack)');
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: {
+                    command: 'store-token',
+                    executionId,
+                    secretName: process.env.PLATFORM_SECRET_NAME || '(derived from token)',
+                },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store-token.js","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { execFileSync } from 'child_process';\nimport * as fs from 'fs';\nimport { fileURLToPath } from 'node:url';\nimport * as os from 'os';\nimport path from 'path';\nimport { LambdaClient, UpdateFunctionCodeCommand } from '@aws-sdk/client-lambda';\nimport { Command } from 'commander';\nimport { APP_VERSION, validateNumber } from '../config/cli.constants.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { decodeTokenPayload } from '../utils/auth-guard.js';\nimport { resolveAwsRegion } from '../utils/aws-env.js';\nimport { upsertSecret, getSecretArn } from '../utils/aws-secrets.js';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withProfileOption, withRegionOption, withSslOptions } from '../utils/command-utils.js';\nimport { toEventBridgeCron } from '../utils/cron.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';\nimport { ensurePlatformToken, resolveSecretName } from '../utils/platform-secret.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nconst RENEW_STACK_NAME = 'pipeline-builder-token-renew';\n// CFN-managed Lambda function name — keep in sync with token-renew-stack.json.\nconst RENEW_LAMBDA_NAME = 'pipeline-builder-token-renew';\n// Default 5-field cron (daily at midnight) when neither --cron nor TOKEN_RENEW_SCHEDULE is set.\nconst DEFAULT_RENEW_CRON = '0 0 * * *';\n\n/**\n * Deploy (or update) the once-a-day token-renewal stack: a scheduled Lambda that\n * re-mints the platform JWT in this same secret before it expires. Mirrors\n * setup-events — `aws cloudformation deploy` for the infra, then a direct\n * UpdateFunctionCode with the thin orchestrator handler compiled alongside this\n * CLI (the handler npm-installs pipeline-manager at runtime and re-runs\n * store-token; see src/lambda/token-renew-handler.ts).\n */\nasync function deployRenewSchedule(opts: {\n  platformUrl: string;\n  secretName: string;\n  days: number;\n  fiveFieldCron: string;\n  region: string;\n  profile?: string;\n}): Promise<string> {\n  const scheduleExpression = toEventBridgeCron(opts.fiveFieldCron); // validates + 15-min guard\n\n  // Name renewal resources per-secret so a scoped-token stack (e.g. the\n  // reporting-ingest credential the event Lambda reads) coexists with the\n  // platform-token stack instead of colliding on the (account-global) IAM\n  // role / Lambda / rule names. The platform secret keeps the bare name\n  // (suffix '') so existing deployments' stack is updated in place, not\n  // duplicated; any other secret appends its trailing path segment.\n  const secretLeaf = opts.secretName.replace(/.*\\//, ''); // 'platform' | 'reporting-ingest' | …\n  const nameSuffix = secretLeaf === 'platform' ? '' : `-${secretLeaf.replace(/[^a-z0-9]+/gi, '-')}`;\n  const stackName = `${RENEW_STACK_NAME}${nameSuffix}`;\n  const lambdaName = `${RENEW_LAMBDA_NAME}${nameSuffix}`;\n\n  printSection('Schedule Renewal');\n  printInfo('Parameters', {\n    stack: stackName,\n    schedule: opts.fiveFieldCron,\n    eventbridge: scheduleExpression,\n    renewDays: opts.days,\n  });\n\n  // Step 1: infra (Lambda gets placeholder code on first create).\n  const templatePath = path.join(__dirname, '../templates/token-renew-stack.json');\n  const cfnArgs = [\n    'cloudformation', 'deploy',\n    '--stack-name', stackName,\n    '--template-file', templatePath,\n    '--parameter-overrides',\n    `PlatformBaseUrl=${opts.platformUrl}`,\n    `PlatformSecretName=${opts.secretName}`,\n    `RenewDays=${opts.days}`,\n    `ScheduleExpression=${scheduleExpression}`,\n    `NameSuffix=${nameSuffix}`,\n    // Pin the handler's runtime npm install to THIS CLI's version (reproducible\n    // renewals instead of a floating \"latest\").\n    `PipelineManagerVersion=${APP_VERSION}`,\n    '--capabilities', 'CAPABILITY_NAMED_IAM',\n    '--no-fail-on-empty-changeset',\n    '--region', opts.region,\n  ];\n  if (opts.profile) cfnArgs.push('--profile', opts.profile);\n  execFileSync('aws', cfnArgs, { stdio: 'inherit' });\n\n  // Step 2: upload the real handler. It's ESM, so the zip entry must be index.mjs\n  // (Handler stays index.handler — nodejs24.x resolves the .mjs extension).\n  const handlerSrc = path.join(__dirname, '../lambda/token-renew-handler.js');\n  if (!fs.existsSync(handlerSrc)) {\n    throw new Error(`Token-renew handler not found at ${handlerSrc} — was the package built?`);\n  }\n  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-renew-'));\n  try {\n    fs.copyFileSync(handlerSrc, path.join(tmpDir, 'index.mjs'));\n    const zipPath = path.join(tmpDir, 'index.zip');\n    execFileSync('zip', ['-j', zipPath, 'index.mjs'], { cwd: tmpDir, stdio: 'pipe' });\n\n    const lambdaClient = new LambdaClient({ region: opts.region });\n    await lambdaClient.send(new UpdateFunctionCodeCommand({\n      FunctionName: lambdaName,\n      ZipFile: fs.readFileSync(zipPath),\n    }));\n  } finally {\n    fs.rmSync(tmpDir, { recursive: true, force: true });\n  }\n\n  printSuccess(`Renewal scheduled (${scheduleExpression})`);\n  return scheduleExpression;\n}\n\n/**\n * Registers the `store-token` command with the CLI program.\n *\n * Generates a long-lived JWT token via the platform API and stores it\n * in AWS Secrets Manager for use by the synth/deploy --store-tokens flag.\n *\n * Requires PLATFORM_TOKEN to be set, or use --email/--password to login inline.\n *\n * By default it ONLY writes the secret. Pass --schedule to also deploy the daily\n * token-renewal stack (a Lambda that auto-renews this token before it expires).\n *\n * @example\n * ```bash\n * pipeline-manager infra store-token --region us-east-1\n * pipeline-manager infra store-token --days 90 --region us-east-1\n * pipeline-manager infra store-token --schedule --region us-east-1          # + daily auto-renewal\n * pipeline-manager infra store-token --schedule --cron '0 3 * * *'          # custom renewal time\n * pipeline-manager infra store-token --days 7 --no-verify-ssl\n * PLATFORM_SECRET_NAME=my-custom-secret pipeline-manager infra store-token   # override the derived name\n * pipeline-manager infra store-token --dry-run\n * pipeline-manager infra store-token -e admin -p '***' --region us-east-1\n * ```\n */\nexport function storeToken(program: Command): void {\n  withSslOptions(\n    withProfileOption(\n      withRegionOption(program\n        .command('store-token')\n        .description('Generate JWT token and store in AWS Secrets Manager for CDK deployments')\n        .option('-u, --identifier <identifier>', 'Username or email (skips PLATFORM_TOKEN requirement)')\n        .option('-p, --password <password>', 'Login password (used with --identifier)')\n        .option('--days <days>', 'Token lifetime in days', '30')\n        .option('--scope <scope>', 'Mint a narrow-scope machine token (e.g. \"reporting:ingest\") and store it at a scope-specific secret path instead of the shared platform secret')\n        .option('--dry-run', 'Show what would be stored without writing to Secrets Manager', false)),\n    )\n      .option('--schedule', 'Also deploy the daily token-renewal stack that auto-renews this token (off by default)', false)\n      .option('--cron <expr>', 'Renewal schedule as a 5-field cron, used with --schedule (default: TOKEN_RENEW_SCHEDULE env or \"0 0 * * *\"; min every 15 minutes)')\n      .option('--json', 'Output result as JSON', false),\n  )\n    .action(async (options) => {\n      const executionId = printCommandHeader('Store Token', undefined, { quiet: options.json });\n\n      try {\n        printSslWarning(options.verifySsl);\n\n        const region = resolveAwsRegion(options.region);\n\n        const days = validateNumber(options.days, 'days', 1, 365);\n        const expiresInSeconds = days * 24 * 60 * 60;\n\n        // Step 0: log in first when creds are available and no PLATFORM_TOKEN is set\n        // (shared with setup-events). Creds come from --email/--password OR the env\n        // vars PLATFORM_IDENTIFIER/PLATFORM_PASSWORD — the env path lets callers like\n        // `provision --with-events` pass them without putting the password on the\n        // command line (where it would show in plans/logs).\n        await ensurePlatformToken(options);\n\n        // Step 1: Authenticate and generate long-lived token\n        printSection('Generate Token');\n\n        const client = await createAuthenticatedClientAsync(options);\n\n        // Resolve secret name from the token's organizationId. An explicit\n        // PLATFORM_SECRET_NAME env wins (escape hatch for system/no-org tokens and\n        // the renewal Lambda); otherwise derive `{prefix}/{orgId}/platform`.\n        // A `--scope` token is a distinct machine credential — store it at a\n        // scope-specific path (`.../reporting-ingest`) so it never clobbers the\n        // full-privilege platform token used by synth/deploy callbacks.\n        const scope = options.scope as string | undefined;\n        const baseSecretName = process.env.PLATFORM_SECRET_NAME || resolveSecretName(process.env.PLATFORM_TOKEN!);\n        const secretName = scope && !process.env.PLATFORM_SECRET_NAME\n          ? baseSecretName.replace(/\\/platform$/, `/${scope.replace(/[^a-z0-9]+/gi, '-')}`)\n          : baseSecretName;\n\n        auditLog('store-token', { executionId, secretName, days, dryRun: options.dryRun });\n\n        printInfo('Parameters', {\n          secretName,\n          region,\n          days,\n          expiresIn: `${expiresInSeconds}s`,\n          dryRun: options.dryRun,\n        });\n\n        printInfo('Requesting token', { expiresIn: `${expiresInSeconds}s (${days} days)` });\n\n        const tokenResponse = await client.post<Record<string, unknown>>(\n          '/api/user/generate-token',\n          { expiresIn: expiresInSeconds, ...(scope ? { scope } : {}) },\n        );\n\n        const tokenData = (tokenResponse as Record<string, unknown>)?.data ?? tokenResponse;\n        const accessToken = (tokenData as Record<string, unknown>)?.accessToken as string | undefined;\n        const refreshToken = (tokenData as Record<string, unknown>)?.refreshToken as string | undefined;\n        const actualExpiresIn = ((tokenData as Record<string, unknown>)?.expiresIn as number) ?? expiresInSeconds;\n\n        if (!accessToken) {\n          throw new Error('Token generation failed — no access token in response');\n        }\n\n        printSuccess(`Token generated (expires in ${actualExpiresIn}s)`);\n\n        const expiresAt = new Date(Date.now() + actualExpiresIn * 1000).toISOString();\n\n        // Schema: { username: orgId, password: JWT, ...metadata }\n        // - username/password fields satisfy CodeBuild's `secretsManagerCredentials`\n        //   (HTTP Basic, sent to pipeline-image-registry's /token endpoint)\n        // - The same JWT is consumed by the plugin-lookup Lambda by reading\n        //   the `password` field\n        // - One Secret per customer account replaces the previous two-secret model\n        // Decode JWT for orgId — it's a stable identifier for the username field;\n        // the actual auth uses the password (JWT) which the token service verifies.\n        // `||` (not `??`): an EMPTY-string organizationId must also fall back. A\n        // sysadmin/system token often carries organizationId=\"\", and CodeBuild\n        // rejects a registry credential whose `username` field is empty with\n        // \"AuthorizationData is malformed, empty field\" — so username must always\n        // be a non-empty value.\n        const payload = decodeTokenPayload(accessToken);\n        const orgId = payload?.organizationId?.trim() || 'unknown-org';\n\n        const secretValue = JSON.stringify({\n          username: orgId,\n          // `password` is the canonical JWT field — read by CodeBuild creds,\n          // plugin-lookup, token-renew, and the event-ingestion Lambda.\n          password: accessToken,\n          ...(refreshToken && { refreshToken }),\n          platformUrl: client.getBaseUrl(),\n          expiresIn: actualExpiresIn,\n          expiresAt,\n          createdAt: new Date().toISOString(),\n        });\n\n        // Dry-run: show what would be stored\n        if (options.dryRun) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              dryRun: true,\n              secretName,\n              region,\n              expiresInDays: days,\n              expiresAt,\n              tokenLength: accessToken.length,\n              hasRefreshToken: !!refreshToken,\n            }, null, 2));\n          } else {\n            console.log('');\n            printSection('Dry Run — No Changes Made');\n            printKeyValue({\n              'Secret Name': secretName,\n              'Region': region,\n              'Expires In': `${days} days`,\n              'Renew By': expiresAt,\n              'Token Length': `${accessToken.length} chars`,\n              'Has Refresh Token': refreshToken ? 'Yes' : 'No',\n            });\n            printSuccess('Dry run complete — no secret was created or updated');\n          }\n          return;\n        }\n\n        // Step 2: Store token in Secrets Manager\n        printSection('Store Token');\n\n        const description = `Platform JWT token (renew by ${expiresAt})`;\n        await upsertSecret(secretName, secretValue, description, { region, profile: options.profile });\n\n        const arn = await getSecretArn(secretName, { region, profile: options.profile });\n\n        // Optionally install the once-a-day renewal stack so this token never lapses.\n        // Off by default — opt in with --schedule (e.g. for the AWS event-ingestion\n        // bundle whose Lambda needs a non-expiring token).\n        let scheduleExpression: string | undefined;\n        if (options.schedule) {\n          const fiveFieldCron = options.cron || process.env.TOKEN_RENEW_SCHEDULE || DEFAULT_RENEW_CRON;\n          scheduleExpression = await deployRenewSchedule({\n            platformUrl: client.getBaseUrl(),\n            secretName,\n            days,\n            fiveFieldCron,\n            region,\n            profile: options.profile,\n          });\n        }\n\n        if (options.json) {\n          console.log(JSON.stringify({\n            success: true,\n            secretName,\n            secretArn: arn,\n            region,\n            expiresInDays: days,\n            expiresAt,\n            schedule: scheduleExpression ?? null,\n          }, null, 2));\n        } else {\n          console.log('');\n          printSection('Token Stored');\n\n          printKeyValue({\n            'Secret Name': secretName,\n            'Secret ARN': arn,\n            'Region': region,\n            'Expires In': `${days} days`,\n            'Renew By': expiresAt,\n            'Auto-Renew': scheduleExpression ? `✓ ${scheduleExpression}` : 'off (pass --schedule to enable)',\n            'Status': '✓ Stored',\n          });\n\n          console.log('');\n          printSuccess('Token stored. To use with synth/deploy:');\n          printInfo(`  export PLATFORM_SECRET_NAME=${secretName}`);\n          printInfo('  pipeline-manager pipeline synth --id <pipeline-id> --store-tokens');\n          console.log('');\n          if (scheduleExpression) {\n            printInfo(`Auto-renewal is active (${scheduleExpression}); the secret refreshes before ${expiresAt}.`);\n          } else {\n            printInfo(`Renew before ${expiresAt} with: pipeline-manager infra store-token --days ${days}`);\n            printInfo('  (or pass --schedule to install a daily auto-renewal stack)');\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'store-token',\n            executionId,\n            secretName: process.env.PLATFORM_SECRET_NAME || '(derived from token)',\n          },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/synth.d.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+/**
+ * Registers the `synth` command with the CLI program.
+ *
+ * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:
+ * 1. --id flag or PIPELINE_ID env var → fetches config from platform API
+ * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)
+ *
+ * Authentication methods (in priority order):
+ * - PLATFORM_TOKEN env var
+ * - --store-tokens → fetch from AWS Secrets Manager
+ *
+ * @example
+ * ```bash
+ * pipeline-manager pipeline synth --id <pipeline-id> --no-verify-ssl
+ * pipeline-manager pipeline synth --id <pipeline-id> --store-tokens
+ * pipeline-manager pipeline synth --quiet --no-notices          # CodePipeline (uses env vars)
+ * ```
+ */
+export declare function synth(program: Command): void;
+//# sourceMappingURL=synth.d.ts.map

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

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

package/dist/commands/synth.js

@@ -0,0 +1,158 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { assertShellSafe } from '../config/cli.constants.js';
+import { auditLog } from '../utils/audit-log.js';
+import { executeCdkShellCommand, resolveBoilerplatePath } from '../utils/cdk-utils.js';
+import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withProfileOption, withRegionOption, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { fetchPipelineProps, printResolvedOrExit } from '../utils/pipeline-config.js';
+import { relaxTlsForCli } from '../utils/tls.js';
+// ESM has no __dirname; derive it from this module's URL.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Fetch pipeline config and set PIPELINE_PROPS env var for the boilerplate app.
+ * Uses createAuthenticatedClientAsync which supports all three auth methods.
+ */
+async function fetchPipelineConfig(pipelineId, options) {
+    const client = await createAuthenticatedClientAsync(options);
+    const { propsWithIds, baseUrl } = await fetchPipelineProps(client, pipelineId);
+    process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');
+    // Propagate the resolved platform base URL into the boilerplate synth (which
+    // inherits process.env). The synth uses it for serverConfig.platformUrl (the
+    // PluginLookup Lambda endpoint) and as the loadRegistryConfig pull-host
+    // fallback. Without this, a URL configured via ~/.pipeline-manager/config.yml
+    // is invisible to the synth subprocess (it reads only the env).
+    if (baseUrl) {
+        process.env.PLATFORM_BASE_URL = baseUrl;
+    }
+    printSuccess('Pipeline configuration loaded');
+}
+/**
+ * Registers the `synth` command with the CLI program.
+ *
+ * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:
+ * 1. --id flag or PIPELINE_ID env var → fetches config from platform API
+ * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)
+ *
+ * Authentication methods (in priority order):
+ * - PLATFORM_TOKEN env var
+ * - --store-tokens → fetch from AWS Secrets Manager
+ *
+ * @example
+ * ```bash
+ * pipeline-manager pipeline synth --id <pipeline-id> --no-verify-ssl
+ * pipeline-manager pipeline synth --id <pipeline-id> --store-tokens
+ * pipeline-manager pipeline synth --quiet --no-notices          # CodePipeline (uses env vars)
+ * ```
+ */
+export function synth(program) {
+    withSslOptions(withRegionOption(withProfileOption(program
+        .command('synth')
+        .description('Run CDK synthesis using pipeline configuration')
+        .option('-i, --id <id>', 'Pipeline ID (or set PIPELINE_ID env var)')
+        .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)
+        .option('--output <dir>', 'CDK output directory', 'cdk.out')))
+        .option('--quiet', 'Suppress CDK output', false)
+        .option('--no-notices', 'Suppress CDK notices')
+        .option('--verbose', 'Show verbose CDK output', false)
+        .option('--json', 'Output result as JSON', false))
+        .option('--show-resolved', 'Print the resolved pipeline config (with {{ ... }} templates expanded) and exit without running CDK', false)
+        .action(async (options) => {
+        const executionId = printCommandHeader('CDK Synthesis', undefined, { quiet: options.json });
+        try {
+            const pipelineId = options.id || process.env.PIPELINE_ID;
+            // --show-resolved: preview templates and exit
+            if (options.showResolved) {
+                await showResolvedPipeline(pipelineId, options);
+                return;
+            }
+            auditLog('synth', { executionId, pipelineId, output: options.output, profile: options.profile });
+            printSslWarning(options.verifySsl);
+            // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it,
+            // but refuse in production (see relaxTlsForCli) — the flag disables cert
+            // validation for ALL outbound TLS, including the AWS SDK.
+            relaxTlsForCli(options.verifySsl, printWarning);
+            // Fetch pipeline config if ID is available and PIPELINE_PROPS not already set
+            if (pipelineId && !process.env.PIPELINE_PROPS) {
+                printInfo('Fetching pipeline configuration', { id: pipelineId });
+                await fetchPipelineConfig(pipelineId, options);
+            }
+            else if (!pipelineId && !process.env.PIPELINE_PROPS) {
+                printWarning('No pipeline ID or PIPELINE_PROPS set');
+                throw new Error('Pipeline ID is required. Use --id <id> or set PIPELINE_ID env var.');
+            }
+            // Local-tool prerequisites (cdk + esbuild/pnpm) are verified up front by
+            // the CLI's preAction hook, so by here they're guaranteed present.
+            // Build cdk synth command
+            if (options.output)
+                assertShellSafe(options.output, 'output');
+            if (options.profile)
+                assertShellSafe(options.profile, 'profile');
+            const boilerplatePath = resolveBoilerplatePath(__dirname);
+            const parts = [
+                'cdk synth',
+                `--app="node ${boilerplatePath}"`,
+                `--output=${options.output}`,
+            ];
+            if (options.profile)
+                parts.push(`--profile=${options.profile}`);
+            if (options.quiet)
+                parts.push('--quiet');
+            if (options.notices === false)
+                parts.push('--no-notices');
+            if (options.verbose)
+                parts.push('--verbose');
+            const command = parts.join(' ');
+            printInfo('Executing', { command: (command.split('--app')[0] ?? '').trim() + ' ...' });
+            console.log('');
+            const result = executeCdkShellCommand(command, {
+                showOutput: !options.quiet,
+            });
+            console.log('');
+            printSection('Synthesis Complete');
+            if (result.success) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        success: true,
+                        executionId,
+                        duration: result.duration,
+                        output: options.output,
+                    }, null, 2));
+                }
+                else {
+                    printKeyValue({
+                        'Execution ID': executionId,
+                        'Duration': `${result.duration}ms`,
+                        'Output': options.output,
+                        'Status': '✓ Success',
+                    });
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'synth', executionId, pipelineId: options.id },
+            });
+        }
+    });
+}
+/**
+ * Fetch the pipeline by ID, apply pass-1 self-referencing template
+ * resolution, and print it to stdout. Used by `synth --show-resolved`
+ * and `deploy --show-resolved` to preview substitution before running CDK.
+ */
+async function showResolvedPipeline(pipelineId, options) {
+    if (!pipelineId) {
+        throw new Error('--show-resolved requires --id or PIPELINE_ID env var');
+    }
+    const client = await createAuthenticatedClientAsync(options);
+    const { propsWithIds } = await fetchPipelineProps(client, pipelineId);
+    await printResolvedOrExit(propsWithIds);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synth.js","sourceRoot":"","sources":["../../src/commands/synth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { Command } from 'commander';\nimport { assertShellSafe } from '../config/cli.constants.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { executeCdkShellCommand, resolveBoilerplatePath } from '../utils/cdk-utils.js';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withProfileOption, withRegionOption, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { fetchPipelineProps, printResolvedOrExit } from '../utils/pipeline-config.js';\nimport { relaxTlsForCli } from '../utils/tls.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = dirname(fileURLToPath(import.meta.url));\n\n/**\n * Fetch pipeline config and set PIPELINE_PROPS env var for the boilerplate app.\n * Uses createAuthenticatedClientAsync which supports all three auth methods.\n */\nasync function fetchPipelineConfig(\n  pipelineId: string,\n  options: { storeTokens?: boolean; verifySsl?: boolean; region?: string; profile?: string },\n): Promise<void> {\n  const client = await createAuthenticatedClientAsync(options);\n  const { propsWithIds, baseUrl } = await fetchPipelineProps(client, pipelineId);\n\n  process.env.PIPELINE_PROPS = Buffer.from(JSON.stringify(propsWithIds)).toString('base64');\n\n  // Propagate the resolved platform base URL into the boilerplate synth (which\n  // inherits process.env). The synth uses it for serverConfig.platformUrl (the\n  // PluginLookup Lambda endpoint) and as the loadRegistryConfig pull-host\n  // fallback. Without this, a URL configured via ~/.pipeline-manager/config.yml\n  // is invisible to the synth subprocess (it reads only the env).\n  if (baseUrl) {\n    process.env.PLATFORM_BASE_URL = baseUrl;\n  }\n\n  printSuccess('Pipeline configuration loaded');\n}\n\n/**\n * Registers the `synth` command with the CLI program.\n *\n * Runs CDK synthesis using the boilerplate app. Pipeline config is resolved from:\n * 1. --id flag or PIPELINE_ID env var → fetches config from platform API\n * 2. PIPELINE_PROPS env var (pre-encoded, from deploy command)\n *\n * Authentication methods (in priority order):\n * - PLATFORM_TOKEN env var\n * - --store-tokens → fetch from AWS Secrets Manager\n *\n * @example\n * ```bash\n * pipeline-manager pipeline synth --id <pipeline-id> --no-verify-ssl\n * pipeline-manager pipeline synth --id <pipeline-id> --store-tokens\n * pipeline-manager pipeline synth --quiet --no-notices          # CodePipeline (uses env vars)\n * ```\n */\nexport function synth(program: Command): void {\n  withSslOptions(\n    withRegionOption(\n      withProfileOption(program\n        .command('synth')\n        .description('Run CDK synthesis using pipeline configuration')\n        .option('-i, --id <id>', 'Pipeline ID (or set PIPELINE_ID env var)')\n        .option('--store-tokens', 'Authenticate using token from AWS Secrets Manager (requires PLATFORM_SECRET_NAME env var)', false)\n        .option('--output <dir>', 'CDK output directory', 'cdk.out')),\n    )\n      .option('--quiet', 'Suppress CDK output', false)\n      .option('--no-notices', 'Suppress CDK notices')\n      .option('--verbose', 'Show verbose CDK output', false)\n      .option('--json', 'Output result as JSON', false),\n  )\n    .option('--show-resolved', 'Print the resolved pipeline config (with {{ ... }} templates expanded) and exit without running CDK', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('CDK Synthesis', undefined, { quiet: options.json });\n\n      try {\n        const pipelineId = options.id || process.env.PIPELINE_ID;\n\n        // --show-resolved: preview templates and exit\n        if (options.showResolved) {\n          await showResolvedPipeline(pipelineId, options);\n          return;\n        }\n\n        auditLog('synth', { executionId, pipelineId, output: options.output, profile: options.profile });\n        printSslWarning(options.verifySsl);\n\n        // Propagate to process.env so CDK constructs (Lambda, CodeBuild) inherit it,\n        // but refuse in production (see relaxTlsForCli) — the flag disables cert\n        // validation for ALL outbound TLS, including the AWS SDK.\n        relaxTlsForCli(options.verifySsl, printWarning);\n\n        // Fetch pipeline config if ID is available and PIPELINE_PROPS not already set\n        if (pipelineId && !process.env.PIPELINE_PROPS) {\n          printInfo('Fetching pipeline configuration', { id: pipelineId });\n          await fetchPipelineConfig(pipelineId, options);\n        } else if (!pipelineId && !process.env.PIPELINE_PROPS) {\n          printWarning('No pipeline ID or PIPELINE_PROPS set');\n          throw new Error('Pipeline ID is required. Use --id <id> or set PIPELINE_ID env var.');\n        }\n\n        // Local-tool prerequisites (cdk + esbuild/pnpm) are verified up front by\n        // the CLI's preAction hook, so by here they're guaranteed present.\n\n        // Build cdk synth command\n        if (options.output) assertShellSafe(options.output, 'output');\n        if (options.profile) assertShellSafe(options.profile, 'profile');\n\n        const boilerplatePath = resolveBoilerplatePath(__dirname);\n        const parts = [\n          'cdk synth',\n          `--app=\"node ${boilerplatePath}\"`,\n          `--output=${options.output}`,\n        ];\n\n        if (options.profile) parts.push(`--profile=${options.profile}`);\n        if (options.quiet) parts.push('--quiet');\n        if (options.notices === false) parts.push('--no-notices');\n        if (options.verbose) parts.push('--verbose');\n\n        const command = parts.join(' ');\n\n        printInfo('Executing', { command: (command.split('--app')[0] ?? '').trim() + ' ...' });\n        console.log('');\n\n        const result = executeCdkShellCommand(command, {\n          showOutput: !options.quiet,\n        });\n\n        console.log('');\n        printSection('Synthesis Complete');\n\n        if (result.success) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              executionId,\n              duration: result.duration,\n              output: options.output,\n            }, null, 2));\n          } else {\n            printKeyValue({\n              'Execution ID': executionId,\n              'Duration': `${result.duration}ms`,\n              'Output': options.output,\n              'Status': '✓ Success',\n            });\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'synth', executionId, pipelineId: options.id },\n        });\n      }\n    });\n}\n\n/**\n * Fetch the pipeline by ID, apply pass-1 self-referencing template\n * resolution, and print it to stdout. Used by `synth --show-resolved`\n * and `deploy --show-resolved` to preview substitution before running CDK.\n */\nasync function showResolvedPipeline(\n  pipelineId: string | undefined,\n  options: { profile?: string; region?: string; storeTokens?: boolean; verifySsl?: boolean },\n): Promise<void> {\n  if (!pipelineId) {\n    throw new Error('--show-resolved requires --id or PIPELINE_ID env var');\n  }\n  const client = await createAuthenticatedClientAsync(options);\n  const { propsWithIds } = await fetchPipelineProps(client, pipelineId);\n  await printResolvedOrExit(propsWithIds);\n}\n"]}

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

@@ -0,0 +1,21 @@
+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.
+ *
+ * @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
+ * ```
+ */
+export declare function uploadPlugin(program: Command): void;
+//# sourceMappingURL=upload-plugin.d.ts.map

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

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